From 7fde63192e5bad836ab422e91a3f7eb7d89e69f8 Mon Sep 17 00:00:00 2001
From: Juan Emmanuel Johnson <jemanjohnson34@gmail.com>
Date: Thu, 14 May 2026 17:27:49 +0200
Subject: [PATCH 1/7] feat: add AsyncGeoData abstract class and consolidate
 shared defaults on GeoDataBase
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds a new ``AsyncGeoData`` abstract class to ``georeader/abstract_reader.py``
that mirrors ``GeoData`` with ``async`` read methods. Concrete async readers
(e.g. the upcoming ``AsyncGeoTIFFReader``) satisfy this interface so user code
can branch on sync-vs-async without isinstance checks.

While here, deduplicate the derived metadata properties that were previously
copy-pasted across ``GeoData`` and would have been copy-pasted again on
``AsyncGeoData``:

- ``bounds``, ``res``, ``footprint`` move up to ``GeoDataBase`` (they only need
  ``transform``, ``crs``, ``shape`` — all already on ``GeoDataBase``).
- ``GeoData`` and ``AsyncGeoData`` keep only the surface that genuinely differs
  per tier: sync vs async ``load`` / ``read_from_window``, plus the read-tier
  metadata stubs (``dtype``, ``dims``, ``fill_value_default``).

No behaviour change for existing ``GeoData`` consumers — ``GeoData.bounds`` etc.
still resolve, just one inheritance level higher. ``GeoTensor`` is unaffected
(no inheritance from these classes).

Tests: adds ``TestAsyncGeoData`` covering inherited defaults (``bounds``,
``res``, ``footprint``) and verifying ``load`` / ``read_from_window`` raise
``NotImplementedError`` on a bare subclass. Full suite: 780 passed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 georeader/abstract_reader.py  | 105 +++++++++++++++++++++++++---------
 tests/test_abstract_reader.py |  81 +++++++++++++++++++++++++-
 2 files changed, 159 insertions(+), 27 deletions(-)

diff --git a/georeader/abstract_reader.py b/georeader/abstract_reader.py
index d32b4a2..54cdb42 100644
--- a/georeader/abstract_reader.py
+++ b/georeader/abstract_reader.py
@@ -165,6 +165,31 @@ def width(self) -> int:
     def height(self) -> int:
         return self.shape[-2]
 
+    @property
+    def res(self) -> Tuple[float, float]:
+        return window_utils.res(self.transform)
+
+    @property
+    def bounds(self) -> Tuple[float, float, float, float]:
+        return window_utils.window_bounds(
+            rasterio.windows.Window(
+                row_off=0, col_off=0, height=self.shape[-2], width=self.shape[-1]
+            ),
+            self.transform,
+        )
+
+    def footprint(self, crs: Optional[str] = None) -> Polygon:
+        pol = window_utils.window_polygon(
+            rasterio.windows.Window(
+                row_off=0, col_off=0, height=self.shape[-2], width=self.shape[-1]
+            ),
+            self.transform,
+        )
+        if (crs is None) or window_utils.compare_crs(self.crs, crs):
+            return pol
+
+        return window_utils.polygon_to_crs(pol, self.crs, crs)
+
 
 @dataclass
 class FakeGeoData:
@@ -197,56 +222,84 @@ def read_from_window(
         raise NotImplementedError(
             "read_from_window method must be implemented in the subclass"
         )
-    
+
     @property
     def values(self) -> np.ndarray:
         # return np.zeros(self.shape, dtype=self.dtype)
         return self.load(boundless=True).values
-    
-    @property
-    def res(self) -> Tuple[float, float]:
-        return window_utils.res(self.transform)
-    
+
     @property
     def dtype(self) -> Any:
         raise NotImplementedError(
             "dtype property must be implemented in the subclass"
         )
-    
+
     @property
     def dims(self) -> list[str]:
         raise NotImplementedError(
             "dims property must be implemented in the subclass"
         )
-    
+
     @property
     def fill_value_default(self) -> Any:
         raise NotImplementedError(
             "fill_value_default property must be implemented in the subclass"
         )
 
-    @property
-    def bounds(self) -> Tuple[float, float, float, float]:
-        return window_utils.window_bounds(
-            rasterio.windows.Window(
-                row_off=0, col_off=0, height=self.shape[-2], width=self.shape[-1]
-            ),
-            self.transform,
+
+AbstractGeoData = GeoData
+
+
+class AsyncGeoData(GeoDataBase):
+    """Async mirror of :class:`GeoData`.
+
+    Concrete async readers (e.g. ``AsyncGeoTIFFReader``) satisfy this
+    interface. User code typed against ``AsyncGeoData`` accepts any
+    conforming async reader without isinstance checks.
+
+    Inherits the metadata surface and derived properties (``transform``,
+    ``crs``, ``shape``, ``width``, ``height``, ``bounds``, ``res``,
+    ``footprint``) from :class:`GeoDataBase`. Adds ``async`` read methods
+    (``load``, ``read_from_window``) and the read-tier metadata
+    properties (``dtype``, ``dims``, ``fill_value_default``).
+
+    Notes
+    -----
+    There is no ``values`` property here (unlike :class:`GeoData`, where it
+    materialises via a sync ``self.load()``). Properties cannot be ``async``,
+    so callers materialise via ``await reader.load()`` and read
+    ``.values`` on the returned :class:`~georeader.geotensor.GeoTensor`.
+    """
+
+    async def load(self, boundless: bool = True) -> GeoTensor:
+        raise NotImplementedError(
+            "load method must be implemented in the subclass"
         )
-    
-    def footprint(self, crs: Optional[str] = None) -> Polygon:
-        pol = window_utils.window_polygon(
-            rasterio.windows.Window(
-                row_off=0, col_off=0, height=self.shape[-2], width=self.shape[-1]
-            ),
-            self.transform,
+
+    async def read_from_window(
+        self, window: rasterio.windows.Window, boundless: bool = True
+    ) -> Union["AsyncGeoData", GeoTensor]:
+        raise NotImplementedError(
+            "read_from_window method must be implemented in the subclass"
         )
-        if (crs is None) or window_utils.compare_crs(self.crs, crs):
-            return pol
 
-        return window_utils.polygon_to_crs(pol, self.crs, crs)
+    @property
+    def dtype(self) -> Any:
+        raise NotImplementedError(
+            "dtype property must be implemented in the subclass"
+        )
 
-AbstractGeoData = GeoData
+    @property
+    def dims(self) -> list[str]:
+        raise NotImplementedError(
+            "dims property must be implemented in the subclass"
+        )
+
+    @property
+    def fill_value_default(self) -> Any:
+        raise NotImplementedError(
+            "fill_value_default property must be implemented in the subclass"
+        )
 
 
 def same_extent(geo1: GeoData, geo2: GeoData, precision: float = 1e-3) -> bool:
diff --git a/tests/test_abstract_reader.py b/tests/test_abstract_reader.py
index 98f9515..c1c893e 100644
--- a/tests/test_abstract_reader.py
+++ b/tests/test_abstract_reader.py
@@ -5,6 +5,7 @@
 - GeoDataBase protocol
 - FakeGeoData dataclass
 - GeoData abstract class
+- AsyncGeoData abstract class
 - same_extent comparison function
 """
 
@@ -12,7 +13,7 @@
 import pytest
 from rasterio.transform import from_origin
 
-from georeader.abstract_reader import FakeGeoData, same_extent
+from georeader.abstract_reader import AsyncGeoData, FakeGeoData, same_extent
 from georeader.geotensor import GeoTensor
 
 
@@ -76,6 +77,84 @@ def test_fake_geodata_is_geodata(self):
         assert hasattr(fake, "shape")
 
 
+class _FakeAsyncReader(AsyncGeoData):
+    """Minimal concrete ``AsyncGeoData`` used to verify inherited defaults.
+
+    Implements only the abstract surface (``transform``, ``crs``, ``shape``,
+    ``dtype``, ``fill_value_default``); the read methods are left raising
+    so the test focuses on metadata + derived-property defaults.
+    """
+
+    def __init__(self, transform, crs, shape, dtype=np.float32, fill_value_default=0):
+        self._transform = transform
+        self._crs = crs
+        self._shape = shape
+        self._dtype = dtype
+        self._fill_value_default = fill_value_default
+
+    @property
+    def transform(self):
+        return self._transform
+
+    @property
+    def crs(self):
+        return self._crs
+
+    @property
+    def shape(self):
+        return self._shape
+
+    @property
+    def dtype(self):
+        return self._dtype
+
+    @property
+    def fill_value_default(self):
+        return self._fill_value_default
+
+
+class TestAsyncGeoData:
+    """Tests for the AsyncGeoData abstract class."""
+
+    def test_subclass_satisfies_surface(self):
+        """A subclass exposing the required attributes satisfies AsyncGeoData."""
+        transform = from_origin(0, 100, 10, 10)
+        reader = _FakeAsyncReader(transform=transform, crs="EPSG:32631", shape=(3, 100, 100))
+
+        # Inherited from GeoDataBase
+        assert reader.width == 100
+        assert reader.height == 100
+        # Defaults inherited from AsyncGeoData (origin (0, 100), 10x10 pixels, 100x100 grid)
+        assert reader.res == (10.0, 10.0)
+        assert reader.bounds == (0.0, -900.0, 1000.0, 100.0)
+
+    def test_footprint_native_crs(self):
+        """Footprint returns the bounding polygon in the reader's native CRS."""
+        transform = from_origin(0, 100, 10, 10)
+        reader = _FakeAsyncReader(transform=transform, crs="EPSG:32631", shape=(3, 100, 100))
+
+        pol = reader.footprint()
+        # Same coverage as bounds — corners match
+        assert pol.bounds == reader.bounds
+
+    @pytest.mark.parametrize("method_name", ["load", "read_from_window"])
+    def test_default_read_methods_raise_not_implemented(self, method_name):
+        """Default ``load`` / ``read_from_window`` raise NotImplementedError on a bare subclass."""
+        import asyncio
+
+        transform = from_origin(0, 100, 10, 10)
+        reader = _FakeAsyncReader(transform=transform, crs="EPSG:32631", shape=(3, 100, 100))
+
+        method = getattr(reader, method_name)
+        if method_name == "load":
+            coro = method()
+        else:
+            coro = method(window=None, boundless=True)
+
+        with pytest.raises(NotImplementedError):
+            asyncio.run(coro)
+
+
 class TestSameExtent:
     """Tests for same_extent comparison function."""
 

From 06fa1a41de5c20d1fbaf873a3b39d9e9a0073479 Mon Sep 17 00:00:00 2001
From: Juan Emmanuel Johnson <jemanjohnson34@gmail.com>
Date: Thu, 14 May 2026 17:46:10 +0200
Subject: [PATCH 2/7] feat(rasterio_reader): add opener/fs/rio_open_kwargs
 bytes-path knobs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`RasterioReader` previously routed all reads through GDAL VSI (libcurl in C)
with no seam to plug in an alternative byte transport. That's fine for the
common case but offers no way to opt into fsspec for niche backends (FTP,
SFTP, GitHub, MinIO with custom auth) or a user-supplied callback for custom
HTTP clients / refreshable tokens.

Add three keyword-only constructor knobs that translate into the rasterio
`opener=` parameter, plus an escape hatch for arbitrary extra kwargs:

- `opener=callable` — passed straight to `rasterio.open(opener=...)`. The
  callable must accept `(path, mode="rb")` — rasterio 1.4 calls it as
  `opener(path)` so the mode default is load-bearing.
- `fs=fsspec.AbstractFileSystem` — shortcut equivalent to `opener=fs.open`.
- `rio_open_kwargs=dict` — escape hatch for arbitrary additional kwargs
  forwarded to every `rasterio.open(...)` call.

`opener=` and `fs=` are mutually exclusive — passing both raises `ValueError`
at construction.

Implementation:
- New private helper `_resolve_open_kwargs()` returns the kwargs dict to
  splat at every `rasterio.open(path, ...)` call site.
- Threaded through all 7 `rasterio.open(...)` call sites in the file.
- All 4 recursive `RasterioReader(...)` constructions (in `read_from_window`,
  `isel`, `__copy__`, `reader_overview`) forward the three knobs so they
  survive across spawned sub-readers.
- Bump `rasterio` floor from `>=1` to `>=1.4` (the version that introduced
  `opener=`).

Docs:
- New `docs/advanced/bytes_path_knobs.ipynb` — fully executable end-to-end
  demo against a local fixture, exercising all three paths plus the
  mutually-exclusive validation.
- Sidebar in `docs/read_S2_SAFE_from_bucket.ipynb` flagging the knobs exist
  for cloud reads (pseudocode only — the executable demo is the new
  advanced notebook).
- Register the advanced notebook in `mkdocs.yml`.

Tests: adds `TestBytesPathKnobs` covering the default path (no knobs),
opener callback round-trip, fsspec shortcut round-trip, mutually-exclusive
validation, and kwargs surviving the recursive construction in
`read_from_window`. Full suite: 785 passed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 docs/advanced/bytes_path_knobs.ipynb | 402 +++++++++++++++++++++++++++
 docs/read_S2_SAFE_from_bucket.ipynb  |  46 ++-
 georeader/rasterio_reader.py         | 106 +++++--
 mkdocs.yml                           |   1 +
 pyproject.toml                       |   2 +-
 tests/test_rasterio_reader.py        |  76 +++++
 6 files changed, 608 insertions(+), 25 deletions(-)
 create mode 100644 docs/advanced/bytes_path_knobs.ipynb

diff --git a/docs/advanced/bytes_path_knobs.ipynb b/docs/advanced/bytes_path_knobs.ipynb
new file mode 100644
index 0000000..366195f
--- /dev/null
+++ b/docs/advanced/bytes_path_knobs.ipynb
@@ -0,0 +1,402 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "c8974398",
+   "metadata": {},
+   "source": [
+    "# RasterioReader bytes-path knobs\n",
+    "\n",
+    "`RasterioReader` exposes three keyword-only knobs that control how raster\n",
+    "bytes flow from storage into rasterio:\n",
+    "\n",
+    "| Knob | Routes bytes through | Use when |\n",
+    "|---|---|---|\n",
+    "| _(default — no kwargs)_ | **GDAL VSI** (`libcurl` in C) | Default for cloud paths (`s3://`, `gs://`, `az://`, `https://`). Fastest sync option, no Python in the byte loop. |\n",
+    "| `opener=callable` | a user callback | Custom HTTP / auth, wrapping an async reader behind a sync facade, refreshable tokens. |\n",
+    "| `fs=fsspec.AbstractFileSystem` | **fsspec** | Niche backends GDAL doesn't speak (FTP, SFTP, GitHub, MinIO with custom endpoint), per-reader credential isolation. Shortcut for `opener=fs.open`. |\n",
+    "\n",
+    "`opener=` and `fs=` are mutually exclusive — passing both raises `ValueError`.\n",
+    "\n",
+    "This notebook demonstrates all three paths against a small **local fixture** so\n",
+    "it runs without credentials or network. The arithmetic and shapes are\n",
+    "identical across the three paths; only the byte transport changes.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d1ada808",
+   "metadata": {},
+   "source": [
+    "## Setup — build a small local GeoTIFF fixture"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "0fd1ad3b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T15:41:12.175127Z",
+     "iopub.status.busy": "2026-05-14T15:41:12.175034Z",
+     "iopub.status.idle": "2026-05-14T15:41:12.317509Z",
+     "shell.execute_reply": "2026-05-14T15:41:12.317260Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fixture: /var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/tmpepws9y1c/demo.tif\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import tempfile\n",
+    "\n",
+    "import numpy as np\n",
+    "import rasterio\n",
+    "from rasterio.transform import from_origin\n",
+    "\n",
+    "tmpdir = tempfile.mkdtemp()\n",
+    "fixture_path = os.path.join(tmpdir, \"demo.tif\")\n",
+    "\n",
+    "# 3-band, 64x64, deterministic content for round-trip checks\n",
+    "np.random.seed(0)\n",
+    "data = np.random.randint(0, 5000, size=(3, 64, 64), dtype=np.int16)\n",
+    "\n",
+    "with rasterio.open(\n",
+    "    fixture_path, \"w\",\n",
+    "    driver=\"GTiff\", height=64, width=64, count=3, dtype=data.dtype,\n",
+    "    crs=\"EPSG:32631\", transform=from_origin(500000.0, 4600000.0, 10.0, 10.0),\n",
+    "    tiled=True, blockxsize=32, blockysize=32, compress=\"deflate\",\n",
+    ") as dst:\n",
+    "    dst.write(data)\n",
+    "\n",
+    "print(f\"Fixture: {fixture_path}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "475a2c80",
+   "metadata": {},
+   "source": [
+    "## Path 1 — Default (GDAL VSI)\n",
+    "\n",
+    "No `opener=` / `fs=` / `rio_open_kwargs=` set. Rasterio handles the byte fetch\n",
+    "via GDAL's VSI layer. For cloud paths this is `libcurl` in C; for local files\n",
+    "it's just `fopen`. This is what every existing `RasterioReader(...)` call has\n",
+    "been doing."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "cfa56329",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T15:41:12.318818Z",
+     "iopub.status.busy": "2026-05-14T15:41:12.318720Z",
+     "iopub.status.idle": "2026-05-14T15:41:12.355334Z",
+     "shell.execute_reply": "2026-05-14T15:41:12.355092Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Internal state:\n",
+      "  _opener            = None\n",
+      "  _fs                = None\n",
+      "  _rio_open_kwargs   = None\n",
+      "  _resolve_open_kwargs() = {}\n",
+      "\n",
+      "Loaded shape: (3, 64, 64), dtype: int16\n"
+     ]
+    }
+   ],
+   "source": [
+    "from georeader.rasterio_reader import RasterioReader\n",
+    "\n",
+    "reader_default = RasterioReader(fixture_path)\n",
+    "\n",
+    "print(\"Internal state:\")\n",
+    "print(f\"  _opener            = {reader_default._opener}\")\n",
+    "print(f\"  _fs                = {reader_default._fs}\")\n",
+    "print(f\"  _rio_open_kwargs   = {reader_default._rio_open_kwargs}\")\n",
+    "print(f\"  _resolve_open_kwargs() = {reader_default._resolve_open_kwargs()}\")\n",
+    "print()\n",
+    "data_default = reader_default.load().values\n",
+    "print(f\"Loaded shape: {data_default.shape}, dtype: {data_default.dtype}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5c3d5c2f",
+   "metadata": {},
+   "source": [
+    "## Path 2 — `opener=callable`\n",
+    "\n",
+    "Pass any callable matching `opener(path, mode='rb') -> file-like`. Rasterio\n",
+    "calls it for each byte range. Useful for custom HTTP clients, refresh-aware\n",
+    "token bearers, or a sync facade over an async reader.\n",
+    "\n",
+    "> **Note on signature.** Rasterio 1.4+ calls `opener(path)` without an\n",
+    "> explicit `mode` argument, so the callable **must** have `mode='rb'` as a\n",
+    "> default. The `fs=` shortcut works because `fsspec`'s `fs.open(path, mode='rb')`\n",
+    "> already provides one."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "793f4bb5",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T15:41:12.356938Z",
+     "iopub.status.busy": "2026-05-14T15:41:12.356822Z",
+     "iopub.status.idle": "2026-05-14T15:41:12.363640Z",
+     "shell.execute_reply": "2026-05-14T15:41:12.363156Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Internal state:\n",
+      "  _opener            = <function my_opener at 0x1190e5300>\n",
+      "  _resolve_open_kwargs() keys = ['opener']\n",
+      "\n",
+      "Loaded shape: (3, 64, 64)\n",
+      "Numerically identical to default path: True\n"
+     ]
+    }
+   ],
+   "source": [
+    "def my_opener(path, mode=\"rb\"):\n",
+    "    \"\"\"Trivial opener that just returns a local binary file handle.\n",
+    "\n",
+    "    In real use this could be a refresh-aware HTTP client, an obstore-backed\n",
+    "    sync facade, or anything else that emits a file-like object.\n",
+    "    \"\"\"\n",
+    "    return open(path, \"rb\")\n",
+    "\n",
+    "reader_opener = RasterioReader(fixture_path, opener=my_opener)\n",
+    "\n",
+    "print(\"Internal state:\")\n",
+    "print(f\"  _opener            = {reader_opener._opener}\")\n",
+    "print(f\"  _resolve_open_kwargs() keys = {list(reader_opener._resolve_open_kwargs().keys())}\")\n",
+    "print()\n",
+    "data_opener = reader_opener.load().values\n",
+    "print(f\"Loaded shape: {data_opener.shape}\")\n",
+    "print(f\"Numerically identical to default path: {np.array_equal(data_opener, data_default)}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "10806237",
+   "metadata": {},
+   "source": [
+    "## Path 3 — `fs=fsspec.AbstractFileSystem`\n",
+    "\n",
+    "Shortcut equivalent to `opener=fs.open`. Use this when you're already\n",
+    "constructing an `fsspec` filesystem object — niche backends, custom auth,\n",
+    "per-reader credential isolation."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "23040510",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T15:41:12.365564Z",
+     "iopub.status.busy": "2026-05-14T15:41:12.365456Z",
+     "iopub.status.idle": "2026-05-14T15:41:12.382532Z",
+     "shell.execute_reply": "2026-05-14T15:41:12.382258Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Internal state:\n",
+      "  _fs                = <fsspec.implementations.local.LocalFileSystem object at 0x107532b90>\n",
+      "  _resolve_open_kwargs() keys = ['opener']\n",
+      "\n",
+      "Loaded shape: (3, 64, 64)\n",
+      "Numerically identical to default path: True\n"
+     ]
+    }
+   ],
+   "source": [
+    "import fsspec\n",
+    "\n",
+    "fs = fsspec.filesystem(\"file\")\n",
+    "reader_fs = RasterioReader(fixture_path, fs=fs)\n",
+    "\n",
+    "print(\"Internal state:\")\n",
+    "print(f\"  _fs                = {reader_fs._fs}\")\n",
+    "print(f\"  _resolve_open_kwargs() keys = {list(reader_fs._resolve_open_kwargs().keys())}\")\n",
+    "print()\n",
+    "data_fs = reader_fs.load().values\n",
+    "print(f\"Loaded shape: {data_fs.shape}\")\n",
+    "print(f\"Numerically identical to default path: {np.array_equal(data_fs, data_default)}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e432bdea",
+   "metadata": {},
+   "source": [
+    "## Validation — `opener=` and `fs=` are mutually exclusive\n",
+    "\n",
+    "Passing both is almost certainly a bug, so the constructor raises `ValueError`\n",
+    "up front rather than silently picking one."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "43ec216f",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T15:41:12.384505Z",
+     "iopub.status.busy": "2026-05-14T15:41:12.384341Z",
+     "iopub.status.idle": "2026-05-14T15:41:12.386208Z",
+     "shell.execute_reply": "2026-05-14T15:41:12.385994Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Caught: RasterioReader: pass either `opener=` or `fs=`, not both. `fs=` is a shortcut for `opener=fs.open`.\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    RasterioReader(fixture_path, opener=my_opener, fs=fs)\n",
+    "except ValueError as e:\n",
+    "    print(f\"Caught: {e}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6a8c847e",
+   "metadata": {},
+   "source": [
+    "## `rio_open_kwargs=` — escape hatch\n",
+    "\n",
+    "Use `rio_open_kwargs=` to forward arbitrary additional keyword arguments to\n",
+    "every `rasterio.open(...)` call. This is the escape hatch for rasterio\n",
+    "options not surfaced as first-class kwargs (e.g. `sharing=False` to disable\n",
+    "the rasterio shared-dataset cache)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "2427b3ab",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T15:41:12.387274Z",
+     "iopub.status.busy": "2026-05-14T15:41:12.387205Z",
+     "iopub.status.idle": "2026-05-14T15:41:12.391311Z",
+     "shell.execute_reply": "2026-05-14T15:41:12.391068Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "_resolve_open_kwargs() = {'sharing': False}\n",
+      "\n",
+      "Loaded shape: (3, 64, 64)\n",
+      "Numerically identical to default path: True\n"
+     ]
+    }
+   ],
+   "source": [
+    "reader_extra = RasterioReader(fixture_path, rio_open_kwargs={\"sharing\": False})\n",
+    "\n",
+    "print(f\"_resolve_open_kwargs() = {reader_extra._resolve_open_kwargs()}\")\n",
+    "print()\n",
+    "data_extra = reader_extra.load().values\n",
+    "print(f\"Loaded shape: {data_extra.shape}\")\n",
+    "print(f\"Numerically identical to default path: {np.array_equal(data_extra, data_default)}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "db1bd0b5",
+   "metadata": {},
+   "source": [
+    "## Choosing a path\n",
+    "\n",
+    "Mental model from the\n",
+    "[geostack ecosystem overview](https://github.com/jejjohnson/research_journal_v2/blob/main/notes/geotoolz/geostack.md):\n",
+    "\n",
+    "- **Default (GDAL VSI)** — fastest for cloud reads. Use unless you have a\n",
+    "  specific reason not to.\n",
+    "- **`fs=`** — when you need a backend GDAL doesn't speak natively, or\n",
+    "  per-reader credential isolation (two `fsspec` filesystems with different\n",
+    "  auth in one process).\n",
+    "- **`opener=`** — full control. Custom HTTP clients, refresh-aware tokens,\n",
+    "  sync wrappers around async readers.\n",
+    "\n",
+    "For high-concurrency *async* fan-out (tile servers, async ML services), the\n",
+    "right answer is usually a different reader entirely:\n",
+    "`georeader.AsyncGeoTIFFReader`, which routes through `obstore` and skips GDAL.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "574fd946",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T15:41:12.392480Z",
+     "iopub.status.busy": "2026-05-14T15:41:12.392394Z",
+     "iopub.status.idle": "2026-05-14T15:41:12.394296Z",
+     "shell.execute_reply": "2026-05-14T15:41:12.394010Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "# Cleanup\n",
+    "import shutil\n",
+    "shutil.rmtree(tmpdir)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/read_S2_SAFE_from_bucket.ipynb b/docs/read_S2_SAFE_from_bucket.ipynb
index 036fe20..4f702d5 100644
--- a/docs/read_S2_SAFE_from_bucket.ipynb
+++ b/docs/read_S2_SAFE_from_bucket.ipynb
@@ -7,7 +7,7 @@
    "source": [
     "## Read Sentinel-2 files from public bucket\n",
     "\n",
-    "* Author: Gonzalo Mateo-García\n",
+    "* Author: Gonzalo Mateo-Garc\u00eda\n",
     "\n",
     "This notebook shows how to read a Sentinel-2 SAFE file from the public Google bucket and reading a subset of it."
    ]
@@ -62,7 +62,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|██████████| 13/13 [00:00<00:00, 26341.04it/s]"
+      "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 13/13 [00:00<00:00, 26341.04it/s]"
      ]
     },
     {
@@ -193,8 +193,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 10 µs, sys: 0 ns, total: 10 µs\n",
-      "Wall time: 18.6 µs\n"
+      "CPU times: user 10 \u00b5s, sys: 0 ns, total: 10 \u00b5s\n",
+      "Wall time: 18.6 \u00b5s\n"
      ]
     },
     {
@@ -306,6 +306,42 @@
     "#     shutil.rmtree(\"deleteme\")"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Alternative bytes paths via `RasterioReader`\n",
+    "\n",
+    "The high-level `S2_SAFE_reader` above routes bytes through GDAL VSI (libcurl in C) by default \u2014 the fastest sync path for public cloud buckets. For workloads that need a different bytes transport (custom auth, niche backends, a Python-side adapter), `RasterioReader` exposes three keyword-only knobs:\n",
+    "\n",
+    "- `opener=callable` \u2014 passed straight to `rasterio.open(opener=...)`. Signature: `opener(path, mode='rb') -> file-like`.\n",
+    "- `fs=fsspec.AbstractFileSystem` \u2014 shortcut for `opener=fs.open`. Useful for FTP / SFTP / GitHub / MinIO with custom auth.\n",
+    "- `rio_open_kwargs=dict` \u2014 escape hatch for arbitrary additional kwargs.\n",
+    "\n",
+    "Sketch (pseudocode \u2014 replace with a path and credentials you have access to):\n",
+    "\n",
+    "```python\n",
+    "from georeader.rasterio_reader import RasterioReader\n",
+    "import fsspec\n",
+    "\n",
+    "granule_jp2 = \"gs://my-bucket/path/to/B04.jp2\"\n",
+    "\n",
+    "# Default: GDAL VSI, what S2_SAFE_reader uses internally\n",
+    "reader_default = RasterioReader(granule_jp2)\n",
+    "\n",
+    "# Alternative: route through fsspec / gcsfs\n",
+    "fs = fsspec.filesystem(\"gcs\", token=\"anon\")\n",
+    "reader_fsspec = RasterioReader(granule_jp2, fs=fs)\n",
+    "\n",
+    "# Or a fully custom opener (refresh-aware HTTP clients, sync facade over async readers, ...)\n",
+    "def my_opener(path, mode=\"rb\"):\n",
+    "    return some_binary_file_like(path)\n",
+    "reader_custom = RasterioReader(granule_jp2, opener=my_opener)\n",
+    "```\n",
+    "\n",
+    "See [`advanced/bytes_path_knobs.ipynb`](advanced/bytes_path_knobs.ipynb) for a fully executable end-to-end demo against a local fixture.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "d45f3f30-150e-487e-a8e6-93df89f542c8",
@@ -327,7 +363,7 @@
     "\tnumber = {1},\n",
     "\turldate = {2023-11-30},\n",
     "\tjournal = {Scientific Reports},\n",
-    "\tauthor = {Portalés-Julià, Enrique and Mateo-García, Gonzalo and Purcell, Cormac and Gómez-Chova, Luis},\n",
+    "\tauthor = {Portal\u00e9s-Juli\u00e0, Enrique and Mateo-Garc\u00eda, Gonzalo and Purcell, Cormac and G\u00f3mez-Chova, Luis},\n",
     "\tmonth = nov,\n",
     "\tyear = {2023},\n",
     "\tpages = {20316},\n",
diff --git a/georeader/rasterio_reader.py b/georeader/rasterio_reader.py
index 65e5041..5d08e35 100644
--- a/georeader/rasterio_reader.py
+++ b/georeader/rasterio_reader.py
@@ -152,7 +152,7 @@
 import rasterio
 import rasterio.windows
 import numpy as np
-from typing import Tuple, Dict, List, Optional, Union, Any
+from typing import Tuple, Dict, List, Optional, Union, Any, Callable
 import warnings
 import numbers
 from georeader import geotensor
@@ -214,6 +214,19 @@ class RasterioReader:
             transform, and shape. Defaults to True.
         rio_env_options (Optional[Dict[str, str]], optional): GDAL environment
             options for reading. Defaults to RIO_ENV_OPTIONS_DEFAULT.
+        opener (Optional[Callable], optional): Keyword-only. A callable passed
+            straight to ``rasterio.open(opener=...)`` for custom byte-range
+            transport. Mutually exclusive with ``fs``. When neither ``opener``
+            nor ``fs`` is set, rasterio routes bytes through GDAL VSI (the
+            default, fastest cloud path).
+        fs (Optional[fsspec.AbstractFileSystem], optional): Keyword-only.
+            Shortcut equivalent to ``opener=fs.open``. Useful for niche
+            backends (FTP, SFTP, GitHub) or custom auth that fsspec speaks
+            but GDAL VSI does not. Mutually exclusive with ``opener``.
+        rio_open_kwargs (Optional[Dict[str, Any]], optional): Keyword-only.
+            Arbitrary additional keyword arguments forwarded to every
+            ``rasterio.open(...)`` call (e.g. ``{"sharing": False}``). Escape
+            hatch for rasterio options not surfaced as first-class kwargs.
 
     Attributes:
         crs (rasterio.crs.CRS): Coordinate reference system.
@@ -303,7 +316,11 @@ def __init__(self, paths:Union[List[str], str], allow_different_shape:bool=False
                  fill_value_default:Optional[Union[int, float]]=None,
                  stack:bool=True, indexes:Optional[List[int]]=None,
                  overview_level:Optional[int]=None, check:bool=True,
-                 rio_env_options:Optional[Dict[str, str]]=None):
+                 rio_env_options:Optional[Dict[str, str]]=None,
+                 *,
+                 opener:Optional[Callable]=None,
+                 fs:Optional[Any]=None,
+                 rio_open_kwargs:Optional[Dict[str, Any]]=None):
 
         # Syntactic sugar
         if isinstance(paths, str):
@@ -315,6 +332,22 @@ def __init__(self, paths:Union[List[str], str], allow_different_shape:bool=False
         else:
             self.rio_env_options = rio_env_options
 
+        # Bytes-path knobs — at most one of opener / fs may be set. ``opener``
+        # is the canonical rasterio.open(opener=...) callback; ``fs`` is an
+        # fsspec shortcut equivalent to ``opener=fs.open``. Both default to
+        # None, in which case rasterio routes bytes through GDAL VSI.
+        # ``rio_open_kwargs`` is an escape hatch for arbitrary additional
+        # keyword arguments passed straight to rasterio.open() (e.g.
+        # ``{"sharing": False}``).
+        if opener is not None and fs is not None:
+            raise ValueError(
+                "RasterioReader: pass either `opener=` or `fs=`, not both. "
+                "`fs=` is a shortcut for `opener=fs.open`."
+            )
+        self._opener = opener
+        self._fs = fs
+        self._rio_open_kwargs = rio_open_kwargs
+
         self.paths = paths
 
         self.stack = stack
@@ -323,7 +356,8 @@ def __init__(self, paths:Union[List[str], str], allow_different_shape:bool=False
         self.fill_value_default = fill_value_default
         self.overview_level = overview_level
         with rasterio.Env(**self._get_rio_options_path(paths[0])):
-            with rasterio.open(paths[0], "r", overview_level=overview_level) as src:
+            with rasterio.open(paths[0], "r", overview_level=overview_level,
+                               **self._resolve_open_kwargs()) as src:
                 self.real_transform = src.transform
                 self.crs = src.crs
                 self.dtype = src.profile["dtype"]
@@ -370,7 +404,8 @@ def __init__(self, paths:Union[List[str], str], allow_different_shape:bool=False
         if check and len(self.paths) > 1:
             for p in self.paths:
                 with rasterio.Env(**self._get_rio_options_path(p)):
-                    with rasterio.open(p, "r", overview_level=overview_level) as src:
+                    with rasterio.open(p, "r", overview_level=overview_level,
+                                       **self._resolve_open_kwargs()) as src:
                         if not src.transform.almost_equals(self.real_transform, 1e-6):
                             raise ValueError(f"Different transform in {self.paths[0]} and {p}: {self.real_transform} {src.transform}")
                         if not str(src.crs).lower() == str(self.crs).lower():
@@ -606,7 +641,7 @@ def tags(self) -> Union[List[Dict[str, str]], Dict[str, str]]:
         tags = []
         for i, p in enumerate(self.paths):
             with rasterio.Env(**self._get_rio_options_path(p)):
-                with rasterio.open(p, mode="r") as src:
+                with rasterio.open(p, mode="r", **self._resolve_open_kwargs()) as src:
                     tags.append(src.tags())
 
         if (not self.stack) and (len(tags) == 1):
@@ -617,6 +652,27 @@ def tags(self) -> Union[List[Dict[str, str]], Dict[str, str]]:
     def _get_rio_options_path(self, path:str) -> Dict[str, str]:
         options = self.rio_env_options
         return geotensor.get_rio_options_path(options=options, path=path)
+
+    def _resolve_open_kwargs(self) -> Dict[str, Any]:
+        """Translate the constructor's opener/fs knobs into rasterio.open kwargs.
+
+        Returns the kwargs dict to splat at every ``rasterio.open(path, ...)``
+        call site. When neither ``opener`` nor ``fs`` was set on the
+        constructor, returns just ``rio_open_kwargs`` (or empty) — rasterio
+        then routes bytes through GDAL VSI as usual. When ``opener`` is set,
+        forwards it as ``opener=...``; when ``fs`` is set, equivalent to
+        ``opener=self._fs.open``.
+
+        Returns:
+            Dict[str, Any]: kwargs suitable for ``**`` splat into
+            ``rasterio.open(...)``.
+        """
+        kwargs: Dict[str, Any] = dict(self._rio_open_kwargs or {})
+        if self._opener is not None:
+            kwargs["opener"] = self._opener
+        elif self._fs is not None:
+            kwargs["opener"] = self._fs.open
+        return kwargs
     
     # This function does not work for e.g. returning the descriptions of the bands
     # @contextmanager
@@ -641,7 +697,7 @@ def descriptions(self) -> Union[List[List[str]], List[str]]:
         descriptions_all = []
         for i, p in enumerate(self.paths):
             with rasterio.Env(**self._get_rio_options_path(p)):
-                with rasterio.open(p) as src:
+                with rasterio.open(p, **self._resolve_open_kwargs()) as src:
                     desc = src.descriptions
 
             if self.stack:
@@ -725,12 +781,15 @@ def read_from_window(self, window:rasterio.windows.Window, boundless:bool=True)
         """
         rst_reader = RasterioReader(list(self.paths),
                                     allow_different_shape=self.allow_different_shape,
-                                    window_focus=self.window_focus, 
+                                    window_focus=self.window_focus,
                                     fill_value_default=self.fill_value_default,
-                                    stack=self.stack, 
+                                    stack=self.stack,
                                     overview_level=self.overview_level,
-                                    check=False, 
-                                    rio_env_options=self.rio_env_options)
+                                    check=False,
+                                    rio_env_options=self.rio_env_options,
+                                    opener=self._opener,
+                                    fs=self._fs,
+                                    rio_open_kwargs=self._rio_open_kwargs)
 
         rst_reader.set_window(window, relative=True, boundless=boundless)
         rst_reader.set_indexes(self.indexes, relative=False)
@@ -875,11 +934,14 @@ def isel(self, sel: Dict[str, Union[slice, List[int], int]], boundless:bool=True
                 slice_.append(slice(0, spatial_shape[_i]))
 
         rst_reader = RasterioReader(paths, allow_different_shape=self.allow_different_shape,
-                                    window_focus=self.window_focus, 
+                                    window_focus=self.window_focus,
                                     fill_value_default=self.fill_value_default,
                                     stack=stack, overview_level=self.overview_level,
                                     check=False,
-                                    rio_env_options=self.rio_env_options)
+                                    rio_env_options=self.rio_env_options,
+                                    opener=self._opener,
+                                    fs=self._fs,
+                                    rio_open_kwargs=self._rio_open_kwargs)
         window_current = rasterio.windows.Window.from_slices(*slice_, boundless=boundless,
                                                              width=self.width, height=self.height)
 
@@ -893,10 +955,12 @@ def isel(self, sel: Dict[str, Union[slice, List[int], int]], boundless:bool=True
 
     def __copy__(self) -> '__class__':
         rst = RasterioReader(self.paths, allow_different_shape=self.allow_different_shape,
-                              window_focus=self.window_focus, 
+                              window_focus=self.window_focus,
                               fill_value_default=self.fill_value_default,
                               stack=self.stack, overview_level=self.overview_level,
-                              check=False, rio_env_options=self.rio_env_options)
+                              check=False, rio_env_options=self.rio_env_options,
+                              opener=self._opener, fs=self._fs,
+                              rio_open_kwargs=self._rio_open_kwargs)
         rst.set_indexes(self.indexes, relative=False)
         return rst
     
@@ -937,7 +1001,7 @@ def overviews(self, index:int=1, time_index:int=0) -> List[int]:
             RasterioReader: Constructor accepts `overview_level` parameter.
         """
         with rasterio.Env(**self._get_rio_options_path(self.paths[time_index])):
-            with rasterio.open(self.paths[time_index]) as src:
+            with rasterio.open(self.paths[time_index], **self._resolve_open_kwargs()) as src:
                 return src.overviews(index)
     
     def reader_overview(self, overview_level:int) -> '__class__':
@@ -996,13 +1060,16 @@ def reader_overview(self, overview_level:int) -> '__class__':
             overview_level = len(self.overviews()) + overview_level
         
         rst = RasterioReader(self.paths, allow_different_shape=self.allow_different_shape,
-                             window_focus=None, 
+                             window_focus=None,
                              fill_value_default=self.fill_value_default,
                              stack=self.stack,
                              indexes=self.indexes,
                              overview_level=overview_level,
                              check=False,
-                             rio_env_options=self.rio_env_options)
+                             rio_env_options=self.rio_env_options,
+                             opener=self._opener,
+                             fs=self._fs,
+                             rio_open_kwargs=self._rio_open_kwargs)
 
         # if self.window_focus hasn't been changed we're good
         if self.window_focus.width == self.real_width and\
@@ -1030,7 +1097,7 @@ def block_windows(self, bidx:int=1, time_idx:int=0) -> List[Tuple[int, rasterio.
 
         """
         with rasterio.Env(**self._get_rio_options_path(self.paths[time_idx])):
-            with rasterio.open(self.paths[time_idx]) as src:
+            with rasterio.open(self.paths[time_idx], **self._resolve_open_kwargs()) as src:
                 windows_return = [(block_idx, rasterio.windows.intersection(window, self.window_focus)) for block_idx, window in src.block_windows(bidx) if rasterio.windows.intersect(self.window_focus, window)]
 
         return windows_return
@@ -1355,7 +1422,8 @@ def read(self, **kwargs) -> np.ndarray:
 
             for i, p in enumerate(self.paths):
                 with rasterio.Env(**self._get_rio_options_path(p)):
-                    with rasterio.open(p, "r", overview_level=self.overview_level) as src:
+                    with rasterio.open(p, "r", overview_level=self.overview_level,
+                                       **self._resolve_open_kwargs()) as src:
                     # rasterio.read API: https://rasterio.readthedocs.io/en/latest/api/rasterio.io.html#rasterio.io.DatasetReader.read
                         read_data = src.read(**kwargs)
 
diff --git a/mkdocs.yml b/mkdocs.yml
index af561be..431bde8 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -46,6 +46,7 @@ nav:
       - Products: carbonmapper/products_explore.ipynb
     - Advanced:
       - VSIL cache problem: advanced/error_read_write_in_remote_path.md
+      - RasterioReader bytes-path knobs: advanced/bytes_path_knobs.ipynb
 plugins:
   - search
   # - social  # Disabled: requires mkdocs-material[imaging] with PIL and cairosvg
diff --git a/pyproject.toml b/pyproject.toml
index 221b2be..9a4ec77 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -14,7 +14,7 @@ include = ["georeader/SolarIrradiance_Thuillier.csv"]
 
 [tool.poetry.dependencies]
 python = ">=3.11,<4.0"
-rasterio = ">=1"
+rasterio = ">=1.4"
 numpy = ">=1"
 shapely = ">=2"
 geopandas = ">=1"
diff --git a/tests/test_rasterio_reader.py b/tests/test_rasterio_reader.py
index 9e7944b..ee3f85b 100644
--- a/tests/test_rasterio_reader.py
+++ b/tests/test_rasterio_reader.py
@@ -12,6 +12,7 @@
 """
 
 import numpy as np
+import pytest
 import rasterio
 import rasterio.windows
 
@@ -663,3 +664,78 @@ def test_copy_preserves_window_focus(self, test_raster_path):
         assert copy.window_focus == reader.window_focus
         assert copy.width == 100
         assert copy.height == 100
+
+
+class TestBytesPathKnobs:
+    """Tests for the ``opener`` / ``fs`` / ``rio_open_kwargs`` keyword-only knobs.
+
+    The default path (no kwargs) routes bytes through GDAL VSI; these tests
+    exercise the two alternative paths against a local fixture and verify
+    they return the same data as the default path.
+    """
+
+    def test_default_path_unchanged(self, test_raster_path):
+        """Default constructor (no opener/fs/rio_open_kwargs) routes through GDAL VSI unchanged."""
+        reader = rasterio_reader.RasterioReader(test_raster_path)
+
+        # No knobs set — internal state confirms.
+        assert reader._opener is None
+        assert reader._fs is None
+        assert reader._rio_open_kwargs is None
+        # Resolved kwargs are empty — rasterio.open receives no extra kwargs,
+        # so GDAL VSI is the bytes path.
+        assert reader._resolve_open_kwargs() == {}
+        # And the reader actually reads.
+        assert reader.load().values.shape == (15, 200, 250)
+
+    def test_opener_callback_reads_same_data(self, test_raster_path):
+        """Opening via a hand-rolled ``opener=`` callback returns the same bytes as the default."""
+        baseline = rasterio_reader.RasterioReader(test_raster_path).load().values
+
+        # Hand-rolled opener: ignore mode, just return a binary file handle.
+        def _opener(path, mode="rb"):
+            return open(path, "rb")
+
+        reader = rasterio_reader.RasterioReader(test_raster_path, opener=_opener)
+        result = reader.load().values
+
+        assert np.array_equal(result, baseline)
+
+    def test_fs_shortcut_reads_same_data(self, test_raster_path):
+        """Opening via ``fs=fsspec.filesystem('file')`` returns the same bytes as the default."""
+        import fsspec
+
+        baseline = rasterio_reader.RasterioReader(test_raster_path).load().values
+
+        fs = fsspec.filesystem("file")
+        reader = rasterio_reader.RasterioReader(test_raster_path, fs=fs)
+        result = reader.load().values
+
+        assert np.array_equal(result, baseline)
+
+    def test_opener_and_fs_mutually_exclusive(self, test_raster_path):
+        """Passing both ``opener=`` and ``fs=`` raises ValueError at construction."""
+        import fsspec
+
+        def _opener(path, mode="rb"):
+            return open(path, "rb")
+
+        fs = fsspec.filesystem("file")
+
+        with pytest.raises(ValueError, match="opener.*fs"):
+            rasterio_reader.RasterioReader(test_raster_path, opener=_opener, fs=fs)
+
+    def test_kwargs_forwarded_through_read_from_window(self, test_raster_path):
+        """``opener=`` survives the recursive RasterioReader construction in ``read_from_window``."""
+
+        def _opener(path, mode="rb"):
+            return open(path, "rb")
+
+        reader = rasterio_reader.RasterioReader(test_raster_path, opener=_opener)
+        sub = reader.read_from_window(
+            rasterio.windows.Window(col_off=0, row_off=0, width=50, height=50)
+        )
+
+        assert sub._opener is _opener
+        # And the sub-reader can actually read.
+        assert sub.load().values.shape[-2:] == (50, 50)

From 99da95b491fc19f6f4ccae7514a4464a8a118bc2 Mon Sep 17 00:00:00 2001
From: Juan Emmanuel Johnson <jemanjohnson34@gmail.com>
Date: Thu, 14 May 2026 17:58:33 +0200
Subject: [PATCH 3/7] feat: add AsyncGeoTIFFReader thin adapter over
 developmentseed/async-geotiff
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

`AsyncGeoTIFFReader` provides async, COG-only reads for high-concurrency
fan-out workloads (tile servers, async ML inference services). It is an
~80-LOC adapter on top of `async-geotiff` (DevSeed) — we don't re-implement
IFD walk, tile-fetch math, decompression dispatch, or request coalescing.
That all lives upstream and we depend on it.

The reader conforms to `AsyncGeoData` (added in the previous commit) so user
code typed against the protocol can swap sync ↔ async readers without
isinstance checks. Same metadata property names as `RasterioReader`
(`crs`, `transform`, `shape`, `dtype`, `bounds`, `fill_value_default`,
`dims`); same method names (`read_from_window`, `read_from_bounds`, `load`)
but each is a coroutine.

Construction is two-phase:
- `AsyncGeoTIFFReader(path, store=...)` — cheap, no I/O
- `await AsyncGeoTIFFReader.open(...)` — fetches the COG header (IFD chain)

After `open()`, sync metadata properties work instantly (just reads off the
already-fetched header). The first pixel-byte fetch happens on the first
`await reader.read_from_window(...)` / `load()`. The `_geotiff` handle is
kept alive between reads, so the header is parsed exactly once per reader
(unlike `RasterioReader`, which opens fresh per call for multi-process
safety). Trade-off: faster repeated reads, not pickleable across processes.

Anti-goals (raise `NotImplementedError`):
- `read_from_bounds(target_crs=...)` — async-geotiff explicitly disclaims
  warp; users either post-warp via `georeader.read.read_reproject_like` or
  fall back to `RasterioReader` with WarpedVRT.
- `read_from_bounds(target_resolution=...)` — same reasoning, no resample.

Dependencies:
- New optional `[async]` extra pulls in `async-geotiff>=0.5,<0.6` (and its
  transitive `async-tiff` + `obspec` chain). Pinned to the 0.5.x line
  because the upstream API is pre-1.0 and may shift between minors.
- Users still pick an `obstore` backend themselves (`S3Store` / `GCSStore` /
  `AzureStore` / `LocalStore`); the right one depends on their cloud.
- Dev group adds `pytest-asyncio`, `obstore`, and `async-geotiff` so the
  tests run in CI.

Tests: `pytest.importorskip("async_geotiff")` gates the whole module so
lean environments skip cleanly. Eight tests cover metadata-after-open,
RuntimeError-before-open, parity with `RasterioReader.read_from_window`
(numerical equality, not just shape), full-load parity, the warp/resample
NotImplementedError boundary, `asyncio.gather` concurrent fan-out across
16 windows, `async with` context manager, and `__repr__` status.

Full suite: 793 passed (8 new + 785 existing).

Note: `poetry.lock` is not regenerated by this commit — all new deps are
optional or dev-only, so the base resolution is unchanged. Run
`poetry lock --no-update` pre-merge to refresh the lockfile metadata.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 georeader/async_geotiff_reader.py  | 331 +++++++++++++++++++++++++++++
 pyproject.toml                     |  21 ++
 tests/test_async_geotiff_reader.py | 168 +++++++++++++++
 3 files changed, 520 insertions(+)
 create mode 100644 georeader/async_geotiff_reader.py
 create mode 100644 tests/test_async_geotiff_reader.py

diff --git a/georeader/async_geotiff_reader.py b/georeader/async_geotiff_reader.py
new file mode 100644
index 0000000..5c58724
--- /dev/null
+++ b/georeader/async_geotiff_reader.py
@@ -0,0 +1,331 @@
+"""
+Async COG reader: thin adapter over ``developmentseed/async-geotiff``.
+
+This module provides :class:`AsyncGeoTIFFReader`, an ``async``-native reader
+for Cloud-Optimized GeoTIFFs (COGs). It is a thin (~80-LOC) adapter on top of
+`async-geotiff <https://github.com/developmentseed/async-geotiff>`_ that
+exposes the same metadata surface as :class:`~georeader.rasterio_reader.RasterioReader`
+and conforms to :class:`~georeader.abstract_reader.AsyncGeoData`. Use it for
+high-concurrency fan-out workloads (tile servers, async ML inference) where
+many reads happen concurrently from one process.
+
+Sync vs Async
+-------------
+
+::
+
+    ┌──────────────────────────────────────────────────────────────────────┐
+    │                  RASTERIOREADER vs ASYNCGEOTIFFREADER                 │
+    ├──────────────────────────────────────────────────────────────────────┤
+    │                                                                       │
+    │  RasterioReader (sync, GDAL)        AsyncGeoTIFFReader (async, COG)  │
+    │  ──────────────────────────         ────────────────────────────     │
+    │                                                                       │
+    │  • Sync reads via rasterio          • Async reads via async-geotiff  │
+    │  • GDAL VSI / fsspec / opener=      • obspec.AsyncStore transport    │
+    │  • Every GDAL driver                • TIFF / COG only                │
+    │  • WarpedVRT reprojection           • No warp / no reproject         │
+    │  • Fresh open() per read            • Persistent GeoTIFF handle      │
+    │                                                                       │
+    │  Use for:                           Use for:                          │
+    │  • Notebooks, batch scripts         • Tile servers fanning out 100s  │
+    │  • Single scenes                    • Async ML inference services    │
+    │  • JP2/NetCDF/HDF5/GRIB            • COG-heavy cloud workflows       │
+    └──────────────────────────────────────────────────────────────────────┘
+
+Construction
+------------
+
+``__init__`` is intentionally cheap — it does not fetch the COG header. Most
+users call the async ``open()`` classmethod which performs the IFD fetch::
+
+    from obstore.store import S3Store
+    from georeader.async_geotiff_reader import AsyncGeoTIFFReader
+
+    store = S3Store(bucket="my-bucket", region="us-east-1")
+    reader = await AsyncGeoTIFFReader.open("scene.tif", store=store)
+
+    # Metadata properties are now sync and instant.
+    print(reader.crs, reader.shape, reader.dtype)
+
+    # Reads are async coroutines.
+    gt = await reader.load()
+
+Why this reader does not warp
+-----------------------------
+
+`async-geotiff explicitly disclaims <https://github.com/developmentseed/async-geotiff#anti-features>`_
+warping, resampling, and automatic overview selection. This reader follows
+suit: ``read_bounds(target_crs=...)`` raises :class:`NotImplementedError`. For
+cross-CRS reads, either fetch in the native CRS and post-warp via
+:func:`georeader.read.read_reproject_like`, or use
+:class:`~georeader.rasterio_reader.RasterioReader` (which has WarpedVRT
+integration on the sync path).
+
+See Also
+--------
+georeader.abstract_reader.AsyncGeoData : Protocol satisfied by this reader.
+georeader.rasterio_reader.RasterioReader : Sync alternative with full GDAL.
+georeader.geotensor.GeoTensor : Carrier type returned by every read.
+
+References
+----------
+- async-geotiff: https://github.com/developmentseed/async-geotiff
+- obstore: https://github.com/developmentseed/obstore
+- obspec: https://github.com/developmentseed/obspec
+"""
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any, Optional, Tuple, Union
+
+import numpy as np
+import rasterio.windows
+
+from georeader import window_utils
+from georeader.abstract_reader import AsyncGeoData
+from georeader.geotensor import GeoTensor
+
+if TYPE_CHECKING:
+    from rasterio import Affine
+
+try:
+    from async_geotiff import GeoTIFF, RasterArray
+    from async_geotiff import Window as _AGTWindow
+
+    _ASYNC_GEOTIFF_AVAILABLE = True
+except ImportError:  # pragma: no cover — exercised by environments without the extra
+    _ASYNC_GEOTIFF_AVAILABLE = False
+    GeoTIFF = None  # type: ignore[assignment,misc]
+    RasterArray = None  # type: ignore[assignment,misc]
+    _AGTWindow = None  # type: ignore[assignment,misc]
+
+
+def _require_async_geotiff() -> None:
+    """Raise a clear error if the optional ``async-geotiff`` extra is missing."""
+    if not _ASYNC_GEOTIFF_AVAILABLE:
+        raise ImportError(
+            "AsyncGeoTIFFReader requires the optional 'async' extra. "
+            "Install with: pip install 'georeader-spaceml[async]'"
+        )
+
+
+class AsyncGeoTIFFReader(AsyncGeoData):
+    """Async COG reader. Thin adapter over :class:`async_geotiff.GeoTIFF`.
+
+    Use for high-concurrency fan-out (tile servers, async ML inference
+    services). For one-off sync reads, use
+    :class:`~georeader.rasterio_reader.RasterioReader` instead.
+
+    The constructor is cheap — it does not fetch the COG header. Call the
+    async ``open()`` classmethod (or use the ``async with`` context manager)
+    to perform the IFD fetch before reading metadata properties.
+
+    Args:
+        path_or_url: Path or URL relative to the ``store``. For local stores,
+            this is the filename inside the store's ``prefix``; for cloud
+            stores, the path inside the bucket.
+        store: An ``obspec``-compatible async store. ``obstore.store``
+            provides ``S3Store`` / ``GCSStore`` / ``AzureStore`` /
+            ``LocalStore`` etc. Required — there is no default.
+        overview_level: Which overview to read from. ``None`` (default)
+            reads at full resolution from the primary IFD. An integer
+            ``i`` reads from ``geotiff.overviews[i]`` (0-based).
+    """
+
+    def __init__(
+        self,
+        path_or_url: str,
+        *,
+        store: Any,
+        overview_level: Optional[int] = None,
+    ) -> None:
+        _require_async_geotiff()
+        self.path_or_url = path_or_url
+        self._store = store
+        self._overview_level = overview_level
+        self._geotiff: Optional[Any] = None
+
+    @classmethod
+    async def open(
+        cls,
+        path_or_url: str,
+        *,
+        store: Any,
+        overview_level: Optional[int] = None,
+    ) -> "AsyncGeoTIFFReader":
+        """Async constructor — fetches and parses the COG header.
+
+        Most users call this rather than ``__init__`` directly. Equivalent to
+        ``__init__`` followed by ``await ...._open_geotiff()``.
+        """
+        self = cls(path_or_url, store=store, overview_level=overview_level)
+        await self._open_geotiff()
+        return self
+
+    async def _open_geotiff(self) -> None:
+        """Fetch the COG header (IFD chain) and cache the GeoTIFF handle."""
+        _require_async_geotiff()
+        self._geotiff = await GeoTIFF.open(self.path_or_url, store=self._store)
+
+    # ----------------------------------------------------------------- internals
+    def _require_open(self) -> Any:
+        if self._geotiff is None:
+            raise RuntimeError(
+                "AsyncGeoTIFFReader not opened — "
+                "call `await AsyncGeoTIFFReader.open(...)` or use `async with`."
+            )
+        return self._geotiff
+
+    @property
+    def _level(self) -> Any:
+        """The async-geotiff object to read from.
+
+        When ``overview_level is None`` this is the full-resolution
+        :class:`async_geotiff.GeoTIFF`; otherwise it's
+        ``geotiff.overviews[overview_level]``. Both expose ``transform``,
+        ``shape``, ``read(window=...)``, etc.
+        """
+        gt = self._require_open()
+        if self._overview_level is None:
+            return gt
+        return gt.overviews[self._overview_level]
+
+    # ------------------------------------------------------------------ metadata
+    @property
+    def crs(self) -> Any:
+        return self._require_open().crs
+
+    @property
+    def transform(self) -> "Affine":
+        return self._level.transform
+
+    @property
+    def shape(self) -> Tuple[int, int, int]:
+        """Returns ``(count, height, width)``.
+
+        Note ``async_geotiff.GeoTIFF.shape`` is just ``(height, width)``;
+        the band count lives on ``.count``.
+        """
+        level = self._level
+        return (self._require_open().count, level.height, level.width)
+
+    @property
+    def dtype(self) -> Any:
+        # async-geotiff returns np.dtype | None directly — no need to re-wrap.
+        return self._require_open().dtype
+
+    @property
+    def fill_value_default(self) -> Any:
+        return self._require_open().nodata
+
+    @property
+    def dims(self) -> list[str]:
+        return ["band", "y", "x"]
+
+    # --------------------------------------------------------------------- reads
+    async def read_from_window(
+        self,
+        window: rasterio.windows.Window,
+        boundless: bool = True,
+    ) -> GeoTensor:
+        """Read a window. Returns a fresh :class:`GeoTensor`.
+
+        The ``boundless`` argument is accepted for protocol parity with
+        :meth:`georeader.abstract_reader.GeoData.read_from_window` but
+        ignored: async-geotiff's :meth:`read` already returns the requested
+        window region with the appropriate fill where data is missing.
+        """
+        del boundless  # accepted for protocol parity, see docstring
+        agt_window = _AGTWindow(
+            col_off=int(window.col_off),
+            row_off=int(window.row_off),
+            width=int(window.width),
+            height=int(window.height),
+        )
+        arr: Any = await self._level.read(window=agt_window)
+        return _rasterarray_to_geotensor(arr, fill_value=self.fill_value_default, crs=self.crs)
+
+    async def read_from_bounds(
+        self,
+        bounds: Tuple[float, float, float, float],
+        *,
+        target_resolution: Optional[Tuple[float, float]] = None,
+        target_crs: Any = None,
+    ) -> GeoTensor:
+        """Read by geographic bounds in the reader's native CRS.
+
+        Raises :class:`NotImplementedError` if ``target_resolution`` or
+        ``target_crs`` are set — this reader does not warp or resample (the
+        underlying ``async-geotiff`` explicitly disclaims warp). For
+        cross-CRS reads, either fetch in the native CRS and post-warp via
+        :func:`georeader.read.read_reproject_like`, or use
+        :class:`~georeader.rasterio_reader.RasterioReader`.
+        """
+        if target_crs is not None or target_resolution is not None:
+            raise NotImplementedError(
+                "AsyncGeoTIFFReader does not warp or resample. "
+                "Read in the native CRS, then call georeader.read.read_reproject_like, "
+                "or use RasterioReader for WarpedVRT-based on-the-fly warping."
+            )
+        win = window_utils.window_from_bounds(self, bounds)
+        return await self.read_from_window(win)
+
+    async def load(self, boundless: bool = True) -> GeoTensor:
+        """Read the whole raster (at the current ``overview_level``).
+
+        ``boundless`` is accepted for protocol parity but ignored — the full
+        extent is always inside the raster's bounds.
+        """
+        del boundless
+        level = self._level
+        full_window = rasterio.windows.Window(
+            col_off=0, row_off=0, width=level.width, height=level.height,
+        )
+        return await self.read_from_window(full_window)
+
+    # -------------------------------------------------------------- lifecycle
+    async def aclose(self) -> None:
+        """No-op — obstore pools its own connections; async-geotiff has no resource to release."""
+        return None
+
+    async def __aenter__(self) -> "AsyncGeoTIFFReader":
+        if self._geotiff is None:
+            await self._open_geotiff()
+        return self
+
+    async def __aexit__(self, *exc: Any) -> None:
+        await self.aclose()
+
+    def __repr__(self) -> str:
+        status = "opened" if self._geotiff is not None else "unopened"
+        return (
+            f"AsyncGeoTIFFReader(path_or_url={self.path_or_url!r}, "
+            f"overview_level={self._overview_level!r}, {status})"
+        )
+
+
+def _rasterarray_to_geotensor(
+    arr: Any,
+    *,
+    fill_value: Any,
+    crs: Any,
+) -> GeoTensor:
+    """Translate :class:`async_geotiff.RasterArray` → :class:`GeoTensor`.
+
+    ``RasterArray.data`` is ``(bands, height, width)``. When ``.mask`` is
+    present (``True`` means valid in async-geotiff's convention) and a
+    ``fill_value`` is available, we substitute the fill where the mask is
+    ``False``. The result carries the same ``transform`` as the source plus
+    the reader's CRS (``RasterArray.crs`` reaches through to the parent
+    GeoTIFF which we already have).
+    """
+    data: np.ndarray = arr.data
+    if arr.mask is not None and fill_value is not None:
+        invalid = np.broadcast_to(~arr.mask, data.shape)
+        data = np.where(invalid, fill_value, data)
+    return GeoTensor(
+        values=data,
+        transform=arr.transform,
+        crs=crs,
+        fill_value_default=fill_value,
+    )
diff --git a/pyproject.toml b/pyproject.toml
index 9a4ec77..c947b00 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -24,6 +24,11 @@ mercantile = ">=1"
 # 'georeader-spaceml[carbonmapper]'`).
 pydantic = {version = ">=2", optional = true}
 requests = {version = ">=2", optional = true}
+# Async COG reader (`georeader.async_geotiff_reader.AsyncGeoTIFFReader`) —
+# thin adapter over developmentseed/async-geotiff. async-geotiff requires
+# numpy >= 2 transitively (via async-tiff), so the extra ships its own
+# numpy floor; the default install keeps numpy >= 1 for the sync path.
+async-geotiff = {version = ">=0.5,<0.6", optional = true}
 
 [tool.poetry.extras]
 # Carbon Mapper reader (`georeader.readers.carbonmapper`) — STAC + plume
@@ -34,9 +39,16 @@ requests = {version = ">=2", optional = true}
 # token loading on top of the file-based primitives in
 # `CarbonMapperConfig`.
 carbonmapper = ["pydantic", "requests"]
+# Async COG reader — pulls in `developmentseed/async-geotiff` and its
+# transitive deps (`async-tiff`, `obspec`). Users still need to install
+# an obstore backend (e.g. `obstore`) themselves; we don't pin a store
+# package because the right one depends on the cloud (S3 vs GCS vs Azure
+# vs local).
+async = ["async-geotiff"]
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.2.0"
+pytest-asyncio = ">=0.23"
 mypy = "^1.5.1"
 pre-commit = "^3.4.0"
 tox = "^4.11.1"
@@ -46,6 +58,11 @@ scikit-image = "^0.24.0"
 # the dependencies are gated as optional for end users.
 pydantic = ">=2"
 requests = ">=2"
+# Async COG reader tests need the async-geotiff package + an obstore
+# backend (LocalStore here). They use ``pytest.importorskip`` so
+# environments without these installed are skipped cleanly.
+async-geotiff = ">=0.5,<0.6"
+obstore = ">=0.7"
 
 [tool.poetry.group.docs.dependencies]
 mkdocs = "^1.4.2"
@@ -99,6 +116,10 @@ show_error_codes = "True"
 
 [tool.pytest.ini_options]
 testpaths = ["tests"]
+# Mode controls how pytest-asyncio discovers async test functions. "strict"
+# requires each async test to be decorated with @pytest.mark.asyncio (won't
+# touch sync tests). Suppresses the default-mode-deprecation warning.
+asyncio_mode = "strict"
 
 [tool.ruff]
 target-version = "py39"
diff --git a/tests/test_async_geotiff_reader.py b/tests/test_async_geotiff_reader.py
new file mode 100644
index 0000000..0ab0207
--- /dev/null
+++ b/tests/test_async_geotiff_reader.py
@@ -0,0 +1,168 @@
+"""
+Tests for georeader.async_geotiff_reader.AsyncGeoTIFFReader.
+
+The tests skip cleanly when the optional ``async`` extra (``async-geotiff``
+plus an obstore backend) isn't installed, so they don't fail in lean
+environments.
+
+Covers:
+- Metadata properties match RasterioReader for the same fixture.
+- ``read_from_window`` produces a GeoTensor numerically equivalent to
+  RasterioReader's read of the same window.
+- ``read_from_bounds(target_crs=...)`` raises NotImplementedError (anti-goal
+  documented in the design).
+- Concurrent fan-out via ``asyncio.gather`` completes without errors.
+- ``async with`` context manager works.
+"""
+
+import os
+import tempfile
+
+import numpy as np
+import pytest
+import rasterio
+import rasterio.windows
+from rasterio.transform import from_origin
+
+# Skip the entire module if the optional async-geotiff stack isn't available.
+async_geotiff = pytest.importorskip("async_geotiff")
+obstore = pytest.importorskip("obstore")
+
+from georeader.abstract_reader import AsyncGeoData  # noqa: E402
+from georeader.async_geotiff_reader import AsyncGeoTIFFReader  # noqa: E402
+from georeader.rasterio_reader import RasterioReader  # noqa: E402
+
+
+@pytest.fixture(scope="module")
+def cog_fixture():
+    """A small tiled GeoTIFF + a LocalStore + the filename relative to that store."""
+    tmpdir = tempfile.mkdtemp()
+    fname = "demo.tif"
+    path = os.path.join(tmpdir, fname)
+
+    np.random.seed(0)
+    data = np.random.randint(0, 5000, size=(3, 64, 64), dtype=np.int16)
+    with rasterio.open(
+        path, "w",
+        driver="GTiff", height=64, width=64, count=3, dtype=data.dtype,
+        crs="EPSG:32631", transform=from_origin(500000.0, 4600000.0, 10.0, 10.0),
+        tiled=True, blockxsize=32, blockysize=32, compress="deflate",
+    ) as dst:
+        dst.write(data)
+
+    store = obstore.store.LocalStore(prefix=tmpdir)
+    yield {"store": store, "fname": fname, "abs_path": path, "tmpdir": tmpdir}
+
+    import shutil
+    shutil.rmtree(tmpdir, ignore_errors=True)
+
+
+class TestAsyncGeoTIFFReader:
+    """Smoke + parity tests for AsyncGeoTIFFReader."""
+
+    @pytest.mark.asyncio
+    async def test_open_populates_metadata(self, cog_fixture):
+        """``await open()`` returns a reader whose metadata properties match the source file."""
+        reader = await AsyncGeoTIFFReader.open(cog_fixture["fname"], store=cog_fixture["store"])
+
+        # Conforms to AsyncGeoData (structural — no inheritance check).
+        assert isinstance(reader, AsyncGeoData)
+        # Metadata matches the fixture.
+        assert reader.shape == (3, 64, 64)
+        assert reader.dtype == np.int16
+        assert reader.dims == ["band", "y", "x"]
+        # bounds is inherited from GeoDataBase default — matches the from_origin transform.
+        assert reader.bounds == (500000.0, 4599360.0, 500640.0, 4600000.0)
+
+    def test_metadata_before_open_raises(self, cog_fixture):
+        """Accessing metadata before ``open()`` raises a clear RuntimeError."""
+        reader = AsyncGeoTIFFReader(cog_fixture["fname"], store=cog_fixture["store"])
+
+        with pytest.raises(RuntimeError, match="not opened"):
+            _ = reader.crs
+
+    @pytest.mark.asyncio
+    async def test_read_parity_with_rasterio_reader(self, cog_fixture):
+        """A windowed async read returns the same bytes as RasterioReader on the same window."""
+        async_reader = await AsyncGeoTIFFReader.open(
+            cog_fixture["fname"], store=cog_fixture["store"],
+        )
+        rio_reader = RasterioReader(cog_fixture["abs_path"])
+
+        win = rasterio.windows.Window(col_off=8, row_off=4, width=32, height=24)
+        async_gt = await async_reader.read_from_window(win)
+        rio_gt = rio_reader.read_from_window(win).load()
+
+        assert async_gt.values.shape == (3, 24, 32)
+        assert np.array_equal(async_gt.values, rio_gt.values)
+
+    @pytest.mark.asyncio
+    async def test_load_returns_full_extent(self, cog_fixture):
+        """``await load()`` reads the whole raster and matches a direct rasterio read."""
+        reader = await AsyncGeoTIFFReader.open(cog_fixture["fname"], store=cog_fixture["store"])
+
+        gt = await reader.load()
+        with rasterio.open(cog_fixture["abs_path"]) as src:
+            expected = src.read()
+
+        assert gt.values.shape == (3, 64, 64)
+        assert np.array_equal(gt.values, expected)
+
+    @pytest.mark.asyncio
+    async def test_read_bounds_warp_not_implemented(self, cog_fixture):
+        """``read_from_bounds(target_crs=...)`` raises ``NotImplementedError``.
+
+        async-geotiff explicitly disclaims warp/resample; this reader follows
+        suit and surfaces the limitation up front rather than silently
+        falling back.
+        """
+        reader = await AsyncGeoTIFFReader.open(cog_fixture["fname"], store=cog_fixture["store"])
+
+        bounds = reader.bounds
+        with pytest.raises(NotImplementedError, match="warp or resample"):
+            await reader.read_from_bounds(bounds, target_crs="EPSG:4326")
+        with pytest.raises(NotImplementedError, match="warp or resample"):
+            await reader.read_from_bounds(bounds, target_resolution=(20.0, 20.0))
+
+    @pytest.mark.asyncio
+    async def test_concurrent_fan_out(self, cog_fixture):
+        """``asyncio.gather`` across many windows from one reader completes successfully.
+
+        Doesn't claim a speedup against this trivial local fixture — the
+        point is to prove the reader survives concurrent ``await`` calls,
+        which is the actual use case (tile servers fanning out 100s of
+        reads).
+        """
+        import asyncio
+
+        reader = await AsyncGeoTIFFReader.open(cog_fixture["fname"], store=cog_fixture["store"])
+
+        windows = [
+            rasterio.windows.Window(col_off=c, row_off=r, width=16, height=16)
+            for r in range(0, 64, 16) for c in range(0, 64, 16)
+        ]
+        results = await asyncio.gather(*[reader.read_from_window(w) for w in windows])
+
+        assert len(results) == 16
+        for gt in results:
+            assert gt.values.shape == (3, 16, 16)
+
+    @pytest.mark.asyncio
+    async def test_async_context_manager(self, cog_fixture):
+        """The ``async with`` context manager opens lazily and closes cleanly."""
+        reader = AsyncGeoTIFFReader(cog_fixture["fname"], store=cog_fixture["store"])
+
+        assert reader._geotiff is None
+        async with reader:
+            assert reader._geotiff is not None
+            gt = await reader.load()
+            assert gt.values.shape == (3, 64, 64)
+
+    @pytest.mark.asyncio
+    async def test_repr(self, cog_fixture):
+        """``__repr__`` reflects open status."""
+        reader = AsyncGeoTIFFReader(cog_fixture["fname"], store=cog_fixture["store"])
+        assert "unopened" in repr(reader)
+
+        await reader._open_geotiff()
+        assert "opened" in repr(reader)

From ea7ed4d2ea56a864204e13c1afc459f26f8600b5 Mon Sep 17 00:00:00 2001
From: Juan Emmanuel Johnson <jemanjohnson34@gmail.com>
Date: Thu, 14 May 2026 18:14:20 +0200
Subject: [PATCH 4/7] docs: AsyncGeoTIFFReader intro notebook + async sidebars
 in existing notebooks
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Adds a full tutorial notebook for `AsyncGeoTIFFReader` and threads short
"async alternative" sidebars into three existing notebooks so users coming
from the sync path discover the async sibling at the relevant entry points.

New notebook `docs/advanced/async_geotiff_reader.ipynb`:
- Two HTML/CSS box-flow diagrams that render natively in both Jupyter and
  mkdocs without any extension — one for `RasterioReader` (three-path
  branch: GDAL VSI / opener / fsspec) and one for `AsyncGeoTIFFReader`
  (linear chain through async-geotiff → async-tiff → obspec → storage).
  Color-coded by layer responsibility (user code / our package / external
  dep / storage).
- A "which reader should I use" decision table.
- End-to-end demo against a local fixture (with a built overview pyramid)
  showing the two-phase laziness model, sync metadata properties,
  numerical parity with `RasterioReader`, the `overview_level` knob with
  side-by-side shape / resolution / byte-size comparisons, concurrent
  fan-out via `asyncio.gather`, and the `async with` context manager.
- A "what this reader does NOT do" section showing
  `NotImplementedError` on `target_crs=` / `target_resolution=`, followed
  by a mini-solution for the common case: load native then warp
  post-step via `read.read_to_crs` / `read.read_reproject_like`.
- A tips/gotchas section covering the two-phase laziness, the explicit
  (not auto-picked) overview-level semantics, multi-process pickleability
  caveats, the `store=` requirement, the inverted mask convention, and
  format scope (TIFF/COG only).

Sidebars added to existing notebooks:
- `notebooks/read_from_tileserver.ipynb` — full executable cell sequence
  against Element 84's public `sentinel-cogs` S3 bucket. Opens a real
  Sentinel-2 L2A COG (10980x10980 uint16 with 4 overviews), then issues
  16 concurrent window reads via `asyncio.gather`. Markdown is explicit
  that XYZ tiles and COG windows are different protocols — not a 1:1
  swap on the same input.
- `docs/advanced/tiling_and_stitching.ipynb` — markdown sidebar with an
  `asyncio.gather` sketch for the per-tile read loop (model inference
  stays sync; only the reads parallelise).
- `docs/read_S2_SAFE_from_bucket.ipynb` — markdown sidebar with a
  `GCSStore` pseudocode block, cross-linking to the intro notebook.

`mkdocs.yml` is updated to register the new tutorial under
"Tutorials → Advanced".

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 docs/advanced/async_geotiff_reader.ipynb | 858 +++++++++++++++++++++++
 docs/advanced/tiling_and_stitching.ipynb |  37 +-
 docs/read_S2_SAFE_from_bucket.ipynb      |  32 +
 mkdocs.yml                               |   1 +
 notebooks/read_from_tileserver.ipynb     | 163 ++++-
 5 files changed, 1076 insertions(+), 15 deletions(-)
 create mode 100644 docs/advanced/async_geotiff_reader.ipynb

diff --git a/docs/advanced/async_geotiff_reader.ipynb b/docs/advanced/async_geotiff_reader.ipynb
new file mode 100644
index 0000000..53fb43d
--- /dev/null
+++ b/docs/advanced/async_geotiff_reader.ipynb
@@ -0,0 +1,858 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "d3f7dadc",
+   "metadata": {},
+   "source": [
+    "# AsyncGeoTIFFReader — async COG reads with `asyncio.gather`\n",
+    "\n",
+    "`AsyncGeoTIFFReader` is georeader's async-native COG reader. It satisfies the\n",
+    "`AsyncGeoData` protocol, exposes the same metadata surface as `RasterioReader`,\n",
+    "and lets you fan out hundreds of reads concurrently from a single process with\n",
+    "`asyncio.gather`. It is a **thin (~80-LOC) adapter** over\n",
+    "[`developmentseed/async-geotiff`](https://github.com/developmentseed/async-geotiff):\n",
+    "IFD walk, tile-fetch math, decompression dispatch, and request coalescing all\n",
+    "live upstream — we contribute the carrier translation and protocol conformance.\n",
+    "\n",
+    "**Audience.** Anyone who has used `RasterioReader` and is wondering when to\n",
+    "reach for the async sibling — what changes, what stays the same, what the\n",
+    "two-phase laziness model looks like, and how to do the things async-geotiff\n",
+    "deliberately doesn't (warp, resample).\n",
+    "\n",
+    "This notebook runs against a small local fixture — no credentials, no network.\n",
+    "The patterns translate to S3 / GCS / Azure by swapping `LocalStore` for the\n",
+    "appropriate `obstore.store.*` class (last section shows the pseudocode).\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1554352d",
+   "metadata": {},
+   "source": [
+    "## How `RasterioReader` fetches bytes (sync, GDAL-backed)\n",
+    "\n",
+    "For context, the sync sibling routes bytes through one of three paths,\n",
+    "controlled by the `opener=` / `fs=` constructor knobs (see\n",
+    "[`bytes_path_knobs.ipynb`](bytes_path_knobs.ipynb)):\n",
+    "\n",
+    "<div style=\"font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; max-width: 760px; margin: 1em 0;\">\n",
+    "  <div style=\"border: 2px solid #1976d2; border-radius: 10px; padding: 14px; background: #e3f2fd;\">\n",
+    "    <strong>Your code</strong><br/>\n",
+    "    <code>reader.load()&nbsp;/&nbsp;reader.read_from_window(w)</code>\n",
+    "  </div>\n",
+    "  <div style=\"text-align: center; font-size: 1.4em; color: #555; line-height: 1;\">&darr;</div>\n",
+    "  <div style=\"border: 2px solid #f57c00; border-radius: 10px; padding: 14px; background: #fff3e0;\">\n",
+    "    <strong>RasterioReader</strong> &middot; wraps <code>rasterio.open(...)</code>\n",
+    "  </div>\n",
+    "  <div style=\"text-align: center; font-size: 1.4em; color: #555; line-height: 1;\">&darr;</div>\n",
+    "  <table style=\"width: 100%; border-collapse: separate; border-spacing: 10px 0; margin: 0;\">\n",
+    "    <tr>\n",
+    "      <td style=\"border: 2px solid #7b1fa2; border-radius: 10px; padding: 10px; background: #f3e5f5; text-align: center; vertical-align: top; width: 33%;\">\n",
+    "        <strong>GDAL VSI</strong><br/>\n",
+    "        <em style=\"color: #555;\">(default)</em><br/>\n",
+    "        <code>opener=None, fs=None</code><br/>\n",
+    "        <small style=\"color: #555;\">libcurl in C; fastest cloud path</small>\n",
+    "      </td>\n",
+    "      <td style=\"border: 2px solid #7b1fa2; border-radius: 10px; padding: 10px; background: #f3e5f5; text-align: center; vertical-align: top; width: 34%;\">\n",
+    "        <strong>Python opener</strong><br/>\n",
+    "        <em style=\"color: #555;\">(custom callback)</em><br/>\n",
+    "        <code>opener=callable</code><br/>\n",
+    "        <small style=\"color: #555;\">custom HTTP / auth, sync facade over async</small>\n",
+    "      </td>\n",
+    "      <td style=\"border: 2px solid #7b1fa2; border-radius: 10px; padding: 10px; background: #f3e5f5; text-align: center; vertical-align: top; width: 33%;\">\n",
+    "        <strong>fsspec</strong><br/>\n",
+    "        <em style=\"color: #555;\">(shortcut for opener)</em><br/>\n",
+    "        <code>fs=fsspec_fs</code><br/>\n",
+    "        <small style=\"color: #555;\">niche backends, custom auth</small>\n",
+    "      </td>\n",
+    "    </tr>\n",
+    "  </table>\n",
+    "  <div style=\"text-align: center; font-size: 1.4em; color: #555; line-height: 1;\">&darr;</div>\n",
+    "  <div style=\"border: 2px solid #388e3c; border-radius: 10px; padding: 14px; background: #c8e6c9; text-align: center;\">\n",
+    "    <strong>Cloud storage / local disk</strong><br/>\n",
+    "    <small style=\"color: #555;\">S3, GCS, Azure, HTTPS, FTP, SFTP, GitHub, local</small>\n",
+    "  </div>\n",
+    "</div>\n",
+    "\n",
+    "All three paths are **synchronous**. The reader opens a fresh `rasterio.DatasetReader`\n",
+    "on each `read()` call, which keeps it pickleable across `multiprocessing` /\n",
+    "`joblib` / Dask workers.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5ba71d0d",
+   "metadata": {},
+   "source": [
+    "## How `AsyncGeoTIFFReader` fetches bytes (async, GDAL-free)\n",
+    "\n",
+    "<div style=\"font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; max-width: 760px; margin: 1em 0;\">\n",
+    "  <div style=\"border: 2px solid #1976d2; border-radius: 10px; padding: 14px; background: #e3f2fd;\">\n",
+    "    <strong>Your code</strong><br/>\n",
+    "    <code>await&nbsp;reader.read_from_window(w)</code>\n",
+    "  </div>\n",
+    "  <div style=\"text-align: center; font-size: 1.4em; color: #555; line-height: 1;\">&darr; delegates to</div>\n",
+    "  <div style=\"border: 2px solid #f57c00; border-radius: 10px; padding: 14px; background: #fff3e0;\">\n",
+    "    <strong>AsyncGeoTIFFReader</strong> &middot; <em style=\"color:#555;\">this package, ~80 LOC adapter</em><br/>\n",
+    "    <small>Carrier translation (RasterArray &rarr; GeoTensor), protocol conformance, overview indexing</small>\n",
+    "  </div>\n",
+    "  <div style=\"text-align: center; font-size: 1.4em; color: #555; line-height: 1;\">&darr; wraps</div>\n",
+    "  <div style=\"border: 2px solid #c2185b; border-radius: 10px; padding: 14px; background: #fce4ec;\">\n",
+    "    <strong>async_geotiff.GeoTIFF</strong> &middot; <em style=\"color:#555;\">DevSeed</em><br/>\n",
+    "    <small>IFD walk, GeoKey parsing, GDAL-metadata parsing, tile-fetch math, RasterArray assembly</small>\n",
+    "  </div>\n",
+    "  <div style=\"text-align: center; font-size: 1.4em; color: #555; line-height: 1;\">&darr; (Rust core, off the event loop)</div>\n",
+    "  <div style=\"border: 2px solid #c2185b; border-radius: 10px; padding: 14px; background: #fce4ec;\">\n",
+    "    <strong>async-tiff</strong><br/>\n",
+    "    <small>Per-tile range fetch &middot; decompression &middot; <strong>request coalescing for adjacent tiles</strong></small>\n",
+    "  </div>\n",
+    "  <div style=\"text-align: center; font-size: 1.4em; color: #555; line-height: 1;\">&darr; via</div>\n",
+    "  <div style=\"border: 2px solid #c2185b; border-radius: 10px; padding: 14px; background: #fce4ec;\">\n",
+    "    <strong>obspec.AsyncStore</strong><br/>\n",
+    "    <small><code>obstore.store</code>: S3Store &middot; GCSStore &middot; AzureStore &middot; HTTPStore &middot; LocalStore</small>\n",
+    "  </div>\n",
+    "  <div style=\"text-align: center; font-size: 1.4em; color: #555; line-height: 1;\">&darr;</div>\n",
+    "  <div style=\"border: 2px solid #388e3c; border-radius: 10px; padding: 14px; background: #c8e6c9; text-align: center;\">\n",
+    "    <strong>Cloud storage / local disk</strong>\n",
+    "  </div>\n",
+    "</div>\n",
+    "\n",
+    "Boxes below `AsyncGeoTIFFReader` are all external dependencies. The Rust core\n",
+    "coalesces adjacent tile reads within one `await` call, so a single window read\n",
+    "already issues parallel HTTP range requests under the hood. The header is\n",
+    "fetched once on `open()`; pixel bytes are fetched per `read_*` / `load` call.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e55ce690",
+   "metadata": {},
+   "source": [
+    "## Which reader should I use?\n",
+    "\n",
+    "| Scenario | Reader | Why |\n",
+    "|---|---|---|\n",
+    "| Notebook exploration, batch scripts, single scenes | `RasterioReader` | Sync API is simpler; one read at a time is the common case. |\n",
+    "| JP2, NetCDF, HDF5, GRIB, non-COG formats | `RasterioReader` | Async reader is TIFF/COG only. |\n",
+    "| Cross-CRS reads via WarpedVRT | `RasterioReader` | Async reader does not warp (see mini-solution below). |\n",
+    "| `multiprocessing` / `joblib` / Dask workers | `RasterioReader` | Opens fresh per `read()`, pickleable across processes. |\n",
+    "| Tile servers fanning out 100s of concurrent reads | `AsyncGeoTIFFReader` | `asyncio.gather` shines when reads are network-bound. |\n",
+    "| Async ML inference services that read many chips per request | `AsyncGeoTIFFReader` | Concurrent fetch from one process, one event loop. |\n",
+    "| Cloud-heavy COG workflows that want to skip GDAL | `AsyncGeoTIFFReader` | `obstore` is Rust + HTTP/2 + native parallel ranges. |\n",
+    "\n",
+    "If you're not sure, **start with `RasterioReader`**. Switch when profiling\n",
+    "shows you're bottlenecked on concurrent cloud reads from one process.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9fd78f8",
+   "metadata": {},
+   "source": [
+    "## Setup — build a small local COG fixture with overviews\n",
+    "\n",
+    "We build a 256&times;256 tiled GeoTIFF with a 2&times;/4&times; overview ladder\n",
+    "so we can demonstrate both full-resolution and overview reads."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d2957fd0",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:02.804072Z",
+     "iopub.status.busy": "2026-05-14T16:10:02.804000Z",
+     "iopub.status.idle": "2026-05-14T16:10:02.949963Z",
+     "shell.execute_reply": "2026-05-14T16:10:02.949744Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fixture: /var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/tmp9ka3ou11/demo.tif\n"
+     ]
+    }
+   ],
+   "source": [
+    "import os\n",
+    "import tempfile\n",
+    "\n",
+    "import numpy as np\n",
+    "import rasterio\n",
+    "from rasterio.enums import Resampling\n",
+    "from rasterio.transform import from_origin\n",
+    "\n",
+    "tmpdir = tempfile.mkdtemp()\n",
+    "fname = \"demo.tif\"\n",
+    "fixture_path = os.path.join(tmpdir, fname)\n",
+    "\n",
+    "np.random.seed(0)\n",
+    "data = np.random.randint(0, 5000, size=(3, 256, 256), dtype=np.int16)\n",
+    "\n",
+    "with rasterio.open(\n",
+    "    fixture_path, \"w\",\n",
+    "    driver=\"GTiff\", height=256, width=256, count=3, dtype=data.dtype,\n",
+    "    crs=\"EPSG:32631\", transform=from_origin(500000.0, 4600000.0, 10.0, 10.0),\n",
+    "    tiled=True, blockxsize=64, blockysize=64, compress=\"deflate\",\n",
+    "    nodata=0,\n",
+    ") as dst:\n",
+    "    dst.write(data)\n",
+    "\n",
+    "# Build a 2x / 4x overview ladder so we can read at three resolutions.\n",
+    "with rasterio.open(fixture_path, \"r+\") as ds:\n",
+    "    ds.build_overviews([2, 4], Resampling.average)\n",
+    "    ds.update_tags(ns=\"rio_overview\", resampling=\"average\")\n",
+    "\n",
+    "print(f\"Fixture: {fixture_path}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6e21d1fd",
+   "metadata": {},
+   "source": [
+    "## Opening a reader — two-phase laziness\n",
+    "\n",
+    "Construction is **two phases**:\n",
+    "\n",
+    "1. **`AsyncGeoTIFFReader(path, store=...)`** — pure constructor, no I/O.\n",
+    "   Property accessors raise `RuntimeError` before `open()`.\n",
+    "2. **`await AsyncGeoTIFFReader.open(...)`** — fetches only the COG header\n",
+    "   (the IFD chain). Cheap. After this, sync metadata properties are instant.\n",
+    "\n",
+    "Pixel bytes are fetched on the *first* `await reader.read_*(...)` /\n",
+    "`await reader.load()` call.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "c1cefe99",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:02.951119Z",
+     "iopub.status.busy": "2026-05-14T16:10:02.951041Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.050652Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.050362Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Before open: AsyncGeoTIFFReader(path_or_url='demo.tif', overview_level=None, unopened)\n",
+      "  reader.crs raised: AsyncGeoTIFFReader not opened — call `await AsyncGeoTIFFReader.open(...)` or use `async with`.\n"
+     ]
+    }
+   ],
+   "source": [
+    "from obstore.store import LocalStore\n",
+    "from georeader.async_geotiff_reader import AsyncGeoTIFFReader\n",
+    "\n",
+    "store = LocalStore(prefix=tmpdir)\n",
+    "\n",
+    "# Phase 1: construct (no I/O). Properties raise until open() is awaited.\n",
+    "reader = AsyncGeoTIFFReader(fname, store=store)\n",
+    "print(f\"Before open: {reader}\")\n",
+    "\n",
+    "try:\n",
+    "    _ = reader.crs\n",
+    "except RuntimeError as e:\n",
+    "    print(f\"  reader.crs raised: {e}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "9cadf716",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:03.051885Z",
+     "iopub.status.busy": "2026-05-14T16:10:03.051780Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.066819Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.066543Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "After open:  AsyncGeoTIFFReader(path_or_url='demo.tif', overview_level=None, opened)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Phase 2: open() fetches the IFD chain only. Pixels are NOT yet downloaded.\n",
+    "reader = await AsyncGeoTIFFReader.open(fname, store=store)\n",
+    "print(f\"After open:  {reader}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9e58427",
+   "metadata": {},
+   "source": [
+    "## Sync metadata properties (after `open()`)\n",
+    "\n",
+    "Same surface as `RasterioReader`: `crs`, `transform`, `shape`, `width`,\n",
+    "`height`, `bounds`, `res`, `dtype`, `fill_value_default`, `dims`, plus the\n",
+    "`footprint(crs)` method. All sync, all instant — they just read fields off\n",
+    "the already-fetched header."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "88b65eed",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:03.068138Z",
+     "iopub.status.busy": "2026-05-14T16:10:03.068057Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.081854Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.081632Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "crs       : EPSG:32631\n",
+      "transform : | 10.00, 0.00, 500000.00|\n",
+      "| 0.00,-10.00, 4600000.00|\n",
+      "| 0.00, 0.00, 1.00|\n",
+      "shape     : (3, 256, 256)    (count, height, width)\n",
+      "dtype     : int16\n",
+      "bounds    : (500000.0, 4597440.0, 502560.0, 4600000.0)\n",
+      "res       : (10.0, 10.0)\n",
+      "dims      : ['band', 'y', 'x']\n",
+      "fill_value_default: 0.0\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(f\"crs       : {reader.crs}\")\n",
+    "print(f\"transform : {reader.transform}\")\n",
+    "print(f\"shape     : {reader.shape}    (count, height, width)\")\n",
+    "print(f\"dtype     : {reader.dtype}\")\n",
+    "print(f\"bounds    : {reader.bounds}\")\n",
+    "print(f\"res       : {reader.res}\")\n",
+    "print(f\"dims      : {reader.dims}\")\n",
+    "print(f\"fill_value_default: {reader.fill_value_default}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d8bf8e5e",
+   "metadata": {},
+   "source": [
+    "## Reading data\n",
+    "\n",
+    "Three async read methods, each returning a `GeoTensor` (numpy-subclass\n",
+    "carrier with `.values`, `.transform`, `.crs`, ...):\n",
+    "\n",
+    "| Method | What it reads |\n",
+    "|---|---|\n",
+    "| `await reader.load()` | The whole raster at the current `overview_level`. |\n",
+    "| `await reader.read_from_window(window)` | A `rasterio.windows.Window` region. |\n",
+    "| `await reader.read_from_bounds(bounds)` | A geographic-bounds region, *native CRS only*. |\n",
+    "\n",
+    "The result is numerically identical to `RasterioReader.read_from_window` on\n",
+    "the same window — let's verify:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "ffb92183",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:03.083000Z",
+     "iopub.status.busy": "2026-05-14T16:10:03.082924Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.118031Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.117808Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "async_gt.values.shape: (3, 48, 64)\n",
+      "sync_gt.values.shape:  (3, 48, 64)\n",
+      "Numerically identical: True\n"
+     ]
+    }
+   ],
+   "source": [
+    "import rasterio.windows\n",
+    "from georeader.rasterio_reader import RasterioReader\n",
+    "\n",
+    "win = rasterio.windows.Window(col_off=32, row_off=16, width=64, height=48)\n",
+    "\n",
+    "async_gt = await reader.read_from_window(win)\n",
+    "sync_gt = RasterioReader(fixture_path).read_from_window(win).load()\n",
+    "\n",
+    "print(f\"async_gt.values.shape: {async_gt.values.shape}\")\n",
+    "print(f\"sync_gt.values.shape:  {sync_gt.values.shape}\")\n",
+    "print(f\"Numerically identical: {np.array_equal(async_gt.values, sync_gt.values)}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "15524724",
+   "metadata": {},
+   "source": [
+    "## Overviews — reading at lower resolutions\n",
+    "\n",
+    "COGs commonly ship with a pyramid of pre-downsampled overviews. Each overview\n",
+    "is a smaller copy of the full raster, useful for quick previews, tile-server\n",
+    "rendering at low zoom, or saving bandwidth when you don't need full detail.\n",
+    "\n",
+    "`AsyncGeoTIFFReader` exposes overviews via the `overview_level` constructor\n",
+    "kwarg:\n",
+    "\n",
+    "- `overview_level=None` (default) &mdash; read from the **primary IFD**\n",
+    "  (full resolution).\n",
+    "- `overview_level=i` &mdash; read from the **i-th overview** (0-based). For\n",
+    "  a `[2, 4]` ladder, `overview_level=0` is the 2&times;-decimated layer and\n",
+    "  `overview_level=1` is the 4&times;-decimated one.\n",
+    "\n",
+    "Properties (`shape`, `transform`, `res`, ...) reflect the active level.\n",
+    "Reads happen against the corresponding pixel grid &mdash; you don't pay for\n",
+    "the bytes of higher-resolution levels."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8042f612",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:03.119207Z",
+     "iopub.status.busy": "2026-05-14T16:10:03.119123Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.123375Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.123163Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "This COG has 2 overview(s)\n",
+      "\n",
+      "Full resolution  : shape=(3, 256, 256), res=(10.0, 10.0)\n",
+      "Overview 0 (2x)  : shape=(3, 128, 128), res=(20.0, 20.0)\n",
+      "Overview 1 (4x)  : shape=(3, 64, 64), res=(40.0, 40.0)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Inspect what overviews this COG has\n",
+    "n_overviews = len(reader._geotiff.overviews)\n",
+    "print(f\"This COG has {n_overviews} overview(s)\")\n",
+    "\n",
+    "# Open readers at three resolutions: full-res, 2x-decimated, 4x-decimated\n",
+    "reader_full = await AsyncGeoTIFFReader.open(fname, store=store)               # primary IFD\n",
+    "reader_ovr0 = await AsyncGeoTIFFReader.open(fname, store=store, overview_level=0)\n",
+    "reader_ovr1 = await AsyncGeoTIFFReader.open(fname, store=store, overview_level=1)\n",
+    "\n",
+    "print()\n",
+    "print(f\"Full resolution  : shape={reader_full.shape}, res={reader_full.res}\")\n",
+    "print(f\"Overview 0 (2x)  : shape={reader_ovr0.shape}, res={reader_ovr0.res}\")\n",
+    "print(f\"Overview 1 (4x)  : shape={reader_ovr1.shape}, res={reader_ovr1.res}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "652c7e8e",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:03.124321Z",
+     "iopub.status.busy": "2026-05-14T16:10:03.124265Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.128916Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.128717Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Full-res load: shape=(3, 256, 256), bytes= 393,216\n",
+      "Overview 0   : shape=(3, 128, 128), bytes=  98,304  (4.0x smaller)\n",
+      "Overview 1   : shape=(3, 64, 64), bytes=  24,576  (16.0x smaller)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Loading the whole raster at each level pays bytes proportional to grid size\n",
+    "gt_full = await reader_full.load()\n",
+    "gt_ovr0 = await reader_ovr0.load()\n",
+    "gt_ovr1 = await reader_ovr1.load()\n",
+    "\n",
+    "print(f\"Full-res load: shape={gt_full.values.shape}, bytes={gt_full.values.nbytes:>8,}\")\n",
+    "print(f\"Overview 0   : shape={gt_ovr0.values.shape}, bytes={gt_ovr0.values.nbytes:>8,}  ({gt_full.values.nbytes/gt_ovr0.values.nbytes:.1f}x smaller)\")\n",
+    "print(f\"Overview 1   : shape={gt_ovr1.values.shape}, bytes={gt_ovr1.values.nbytes:>8,}  ({gt_full.values.nbytes/gt_ovr1.values.nbytes:.1f}x smaller)\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "93bf2772",
+   "metadata": {},
+   "source": [
+    "## Concurrent fan-out — the killer feature\n",
+    "\n",
+    "The point of going async is to fan out many reads concurrently from one\n",
+    "process. `asyncio.gather` does it in one line.\n",
+    "\n",
+    "**Honest disclaimer about local fixtures:** speedups from async only show up\n",
+    "against meaningful per-read latency &mdash; typically *cloud* reads. Against\n",
+    "a local file, the overhead can even dominate. Don't draw timing conclusions\n",
+    "from this cell; it proves the fan-out *works*, which is the actual question.\n",
+    "Real wins arrive when each `read_from_window` is a 50&ndash;200 ms network\n",
+    "round-trip and you have 100+ of them to issue.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "8d7bbf09",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:03.130080Z",
+     "iopub.status.busy": "2026-05-14T16:10:03.130009Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.135912Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.135636Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Issued 16 concurrent reads against one reader\n",
+      "All shapes correct: True\n"
+     ]
+    }
+   ],
+   "source": [
+    "import asyncio\n",
+    "\n",
+    "# 16 non-overlapping 64x64 windows tiling the 256x256 raster\n",
+    "windows = [\n",
+    "    rasterio.windows.Window(col_off=c, row_off=r, width=64, height=64)\n",
+    "    for r in range(0, 256, 64) for c in range(0, 256, 64)\n",
+    "]\n",
+    "\n",
+    "results = await asyncio.gather(*[reader.read_from_window(w) for w in windows])\n",
+    "\n",
+    "print(f\"Issued {len(windows)} concurrent reads against one reader\")\n",
+    "print(f\"All shapes correct: {all(r.values.shape == (3, 64, 64) for r in results)}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fc7d42ca",
+   "metadata": {},
+   "source": [
+    "## `async with` — context manager\n",
+    "\n",
+    "When you don't want to manage `open()` / `aclose()` yourself, use the async\n",
+    "context manager. It opens lazily on enter and runs `aclose()` on exit\n",
+    "(currently a no-op since `obstore` pools its own connections)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "925a8590",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:03.137031Z",
+     "iopub.status.busy": "2026-05-14T16:10:03.136964Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.140968Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.140732Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Inside the context: shape=(3, 256, 256), dtype=int16\n"
+     ]
+    }
+   ],
+   "source": [
+    "ctx_reader = AsyncGeoTIFFReader(fname, store=store)\n",
+    "\n",
+    "async with ctx_reader:\n",
+    "    gt = await ctx_reader.load()\n",
+    "    print(f\"Inside the context: shape={gt.values.shape}, dtype={gt.values.dtype}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9f3d5ab7",
+   "metadata": {},
+   "source": [
+    "## What this reader does NOT do\n",
+    "\n",
+    "`async-geotiff` explicitly disclaims warp / resample / overview\n",
+    "auto-selection. We follow the same boundary &mdash; calling\n",
+    "`read_from_bounds(target_crs=...)` or `read_from_bounds(target_resolution=...)`\n",
+    "raises `NotImplementedError` with a clear error message:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "6efef835",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:03.142037Z",
+     "iopub.status.busy": "2026-05-14T16:10:03.141976Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.143668Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.143485Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "NotImplementedError: AsyncGeoTIFFReader does not warp or resample. Read in the native CRS, then call georeader.read.read_reproject_like, or use RasterioReader for WarpedVRT-based on-the-fly warping.\n"
+     ]
+    }
+   ],
+   "source": [
+    "try:\n",
+    "    await reader.read_from_bounds(reader.bounds, target_crs=\"EPSG:4326\")\n",
+    "except NotImplementedError as e:\n",
+    "    print(f\"NotImplementedError: {e}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0d0644d5",
+   "metadata": {},
+   "source": [
+    "### Mini-solution: warp / reproject **after** loading\n",
+    "\n",
+    "When you need a different CRS or resolution, the recommended pattern is\n",
+    "**fetch native, then warp post-step** via georeader's sync warp helpers. Two\n",
+    "shapes cover most cases:\n",
+    "\n",
+    "- **`read.read_to_crs(gt, dst_crs=...)`** &mdash; reproject a loaded\n",
+    "  `GeoTensor` to a target CRS with a derived transform.\n",
+    "- **`read.read_reproject_like(gt, gt_target)`** &mdash; reproject onto the\n",
+    "  exact grid of another `GeoTensor` (matching extent, resolution, CRS).\n",
+    "\n",
+    "Both are sync and use `rasterio.warp` under the hood (which means they pull\n",
+    "GDAL into the dependency cone &mdash; that is the cost of warping)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "53325ccd",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:03.144586Z",
+     "iopub.status.busy": "2026-05-14T16:10:03.144529Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.184328Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.184105Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Native: crs=EPSG:32631, shape=(3, 256, 256), transform=| 10.00, 0.00, 500000.00|\n",
+      "| 0.00,-10.00, 4600000.00|\n",
+      "| 0.00, 0.00, 1.00|\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Warped to WGS84: crs=EPSG:4326, shape=(3, 218, 290)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 1. Read native CRS via the async reader\n",
+    "gt_native = await reader.load()\n",
+    "print(f\"Native: crs={gt_native.crs}, shape={gt_native.values.shape}, transform={gt_native.transform}\")\n",
+    "\n",
+    "# 2a. Warp to a target CRS (sync post-step)\n",
+    "from georeader import read\n",
+    "\n",
+    "gt_wgs84 = read.read_to_crs(gt_native, dst_crs=\"EPSG:4326\")\n",
+    "print(f\"Warped to WGS84: crs={gt_wgs84.crs}, shape={gt_wgs84.values.shape}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "438e0a27",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:03.185525Z",
+     "iopub.status.busy": "2026-05-14T16:10:03.185453Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.208690Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.208424Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Aligned to target grid: shape=(3, 200, 200), transform=| 12.00, 0.00, 500000.00|\n",
+      "| 0.00,-12.00, 4600000.00|\n",
+      "| 0.00, 0.00, 1.00|\n"
+     ]
+    }
+   ],
+   "source": [
+    "# 2b. Reproject onto another GeoTensor's grid (e.g. for stack alignment)\n",
+    "from georeader.geotensor import GeoTensor\n",
+    "\n",
+    "target_grid = GeoTensor(\n",
+    "    values=np.zeros((3, 200, 200), dtype=np.int16),\n",
+    "    transform=from_origin(500000.0, 4600000.0, 12.0, 12.0),  # 12m pixels instead of 10m\n",
+    "    crs=\"EPSG:32631\",\n",
+    ")\n",
+    "\n",
+    "gt_aligned = read.read_reproject_like(gt_native, target_grid)\n",
+    "print(f\"Aligned to target grid: shape={gt_aligned.values.shape}, transform={gt_aligned.transform}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "719240d9",
+   "metadata": {},
+   "source": [
+    "## Tips and gotchas\n",
+    "\n",
+    "- **Two-phase laziness.** Header on `open()`, pixels on `read()`. Properties\n",
+    "  raise `RuntimeError` before `open()`. Use `async with` if you want to skip\n",
+    "  the explicit `open` + `aclose` dance.\n",
+    "- **Not pickleable across processes.** The `_geotiff` handle is alive\n",
+    "  between reads (faster repeated reads) but won't survive a\n",
+    "  `multiprocessing` / `joblib` / Dask worker boundary. For multi-process,\n",
+    "  open the reader fresh in each worker, or use `RasterioReader`.\n",
+    "- **`store=` is required &mdash; no default.** Pick the right `obstore` Store per\n",
+    "  cloud:\n",
+    "  - `obstore.store.S3Store(bucket=..., region=...)` for AWS S3\n",
+    "  - `obstore.store.GCSStore(bucket=..., ...)` for Google Cloud Storage\n",
+    "  - `obstore.store.AzureStore(container_name=..., ...)` for Azure Blob\n",
+    "  - `obstore.store.LocalStore(prefix=dir)` for local disk\n",
+    "  - `obstore.store.HTTPStore.from_url(url)` for HTTPS\n",
+    "- **Overviews.** `overview_level=None` (default) reads full resolution;\n",
+    "  `overview_level=i` reads the i-th overview (0-based). The COG must\n",
+    "  actually have overviews — `overview_level=0` on a non-overview file\n",
+    "  raises `IndexError`. Auto-picking the right level for a target resolution\n",
+    "  isn't done for you; pick explicitly based on `len(reader._geotiff.overviews)`.\n",
+    "- **TIFF/COG only.** For JP2, NetCDF, HDF5, GRIB, use `RasterioReader`.\n",
+    "- **Mask convention.** `async-geotiff`'s `RasterArray.mask` uses\n",
+    "  `True = valid` (inverse of numpy MA's convention). The adapter handles\n",
+    "  this and substitutes `fill_value_default` where invalid.\n",
+    "- **No warp / resample / overview auto-selection.** Use the mini-solution\n",
+    "  above (load native + `read.read_to_crs` / `read.read_reproject_like`), or\n",
+    "  reach for `RasterioReader` with WarpedVRT for one-shot on-the-fly warping.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ac10b116",
+   "metadata": {},
+   "source": [
+    "## Going to the cloud (pseudocode)\n",
+    "\n",
+    "The flow is identical &mdash; swap `LocalStore` for the appropriate\n",
+    "`obstore.store.*` class. The reader doesn't care which cloud is behind the\n",
+    "store.\n",
+    "\n",
+    "```python\n",
+    "from obstore.store import S3Store\n",
+    "from georeader.async_geotiff_reader import AsyncGeoTIFFReader\n",
+    "\n",
+    "store = S3Store(bucket=\"my-bucket\", region=\"us-east-1\")\n",
+    "reader = await AsyncGeoTIFFReader.open(\"scene.tif\", store=store)\n",
+    "\n",
+    "# All the same methods work\n",
+    "gt = await reader.load()\n",
+    "\n",
+    "# Fan out across many windows from one bucket:\n",
+    "chips = await asyncio.gather(*[reader.read_from_window(w) for w in windows])\n",
+    "```\n",
+    "\n",
+    "For credentials, look at the relevant `obstore.store.*` constructor — each\n",
+    "store accepts the standard cloud-specific auth: env-vars, IAM roles, SAS\n",
+    "tokens, etc. See the\n",
+    "[obstore docs](https://developmentseed.org/obstore/latest/) for the full\n",
+    "matrix.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d7572057",
+   "metadata": {},
+   "source": [
+    "## Cleanup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "2835076c",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:10:03.209920Z",
+     "iopub.status.busy": "2026-05-14T16:10:03.209848Z",
+     "iopub.status.idle": "2026-05-14T16:10:03.211685Z",
+     "shell.execute_reply": "2026-05-14T16:10:03.211393Z"
+    }
+   },
+   "outputs": [],
+   "source": [
+    "import shutil\n",
+    "shutil.rmtree(tmpdir)\n"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/advanced/tiling_and_stitching.ipynb b/docs/advanced/tiling_and_stitching.ipynb
index 7e79c63..b296013 100644
--- a/docs/advanced/tiling_and_stitching.ipynb
+++ b/docs/advanced/tiling_and_stitching.ipynb
@@ -7,7 +7,7 @@
    "source": [
     "# Tiling and stitching segmentation outputs\n",
     "\n",
-    "* Author: Gonzalo Mateo-García\n",
+    "* Author: Gonzalo Mateo-Garc\u00eda\n",
     "\n",
     "This tutorial shows how to run an AI model by fix-size tiles following the recommendations of *Huang et al. 2018*:\n",
     "\n",
@@ -76,7 +76,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 13/13 [00:00<00:00, 12409.18it/s]"
+      "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 13/13 [00:00<00:00, 12409.18it/s]"
      ]
     },
     {
@@ -215,7 +215,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 15/15 [00:05<00:00,  2.76it/s]\n"
+      "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 15/15 [00:05<00:00,  2.76it/s]\n"
      ]
     }
    ],
@@ -299,6 +299,35 @@
     "cloudsen12.plot_cloudSEN12mask(output_tensor,ax=ax[1])"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Async fan-out \u2014 swap the read loop\n",
+    "\n",
+    "The loop above issues one read per tile via `RasterioReader` (sync, GDAL VSI). For workloads where many tiles come from cloud storage and reads are network-bound (a tile server, an async ML inference service), swap the per-tile read for `AsyncGeoTIFFReader` + `asyncio.gather`. The model inference itself stays sync \u2014 only the reads parallelise.\n",
+    "\n",
+    "Sketch (replace the read step in the tiling loop):\n",
+    "\n",
+    "```python\n",
+    "import asyncio\n",
+    "from obstore.store import S3Store\n",
+    "from georeader.async_geotiff_reader import AsyncGeoTIFFReader\n",
+    "\n",
+    "store = S3Store(bucket=\"my-bucket\", region=\"us-east-1\")\n",
+    "reader = await AsyncGeoTIFFReader.open(\"scene.tif\", store=store)\n",
+    "\n",
+    "# Fan out all tile reads concurrently from one process.\n",
+    "chips = await asyncio.gather(*[reader.read_from_window(w) for w in windows])\n",
+    "\n",
+    "# Then run the (sync) model on each chip and stitch as before.\n",
+    "predictions = [model(chip.values) for chip in chips]\n",
+    "stitched = stitch(predictions, windows, ...)\n",
+    "```\n",
+    "\n",
+    "See [`async_geotiff_reader.ipynb`](async_geotiff_reader.ipynb) for the full tutorial \u2014 when to use which reader, the two-phase laziness model, gotchas, and a mini-solution for post-load warp/reproject.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "9a1d807c-be46-401e-adc4-d135e69ea17f",
@@ -319,7 +348,7 @@
     "\turl = {https://www.sciencedirect.com/science/article/pii/S2352340924008163},\n",
     "\tdoi = {10.1016/j.dib.2024.110852},\n",
     "\tjournal = {Data in Brief},\n",
-    "\tauthor = {Aybar, Cesar and Bautista, Lesly and Montero, David and Contreras, Julio and Ayala, Daryl and Prudencio, Fernando and Loja, Jhomira and Ysuhuaylas, Luis and Herrera, Fernando and Gonzales, Karen and Valladares, Jeanett and Flores, Lucy A. and Mamani, Evelin and Quiñonez, Maria and Fajardo, Rai and Espinoza, Wendy and Limas, Antonio and Yali, Roy and Alcántara, Alejandro and Leyva, Martin and Loayza-Muro, Rau´l and Willems, Bram and Mateo-García, Gonzalo and Gómez-Chova, Luis},\n",
+    "\tauthor = {Aybar, Cesar and Bautista, Lesly and Montero, David and Contreras, Julio and Ayala, Daryl and Prudencio, Fernando and Loja, Jhomira and Ysuhuaylas, Luis and Herrera, Fernando and Gonzales, Karen and Valladares, Jeanett and Flores, Lucy A. and Mamani, Evelin and Qui\u00f1onez, Maria and Fajardo, Rai and Espinoza, Wendy and Limas, Antonio and Yali, Roy and Alc\u00e1ntara, Alejandro and Leyva, Martin and Loayza-Muro, Rau\u00b4l and Willems, Bram and Mateo-Garc\u00eda, Gonzalo and G\u00f3mez-Chova, Luis},\n",
     "\tmonth = aug,\n",
     "\tyear = {2024},\n",
     "\tpages = {110852},\n",
diff --git a/docs/read_S2_SAFE_from_bucket.ipynb b/docs/read_S2_SAFE_from_bucket.ipynb
index 4f702d5..d97eeec 100644
--- a/docs/read_S2_SAFE_from_bucket.ipynb
+++ b/docs/read_S2_SAFE_from_bucket.ipynb
@@ -342,6 +342,38 @@
     "See [`advanced/bytes_path_knobs.ipynb`](advanced/bytes_path_knobs.ipynb) for a fully executable end-to-end demo against a local fixture.\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Async alternative \u2014 `AsyncGeoTIFFReader` for high-concurrency reads\n",
+    "\n",
+    "`S2_SAFE_reader` and the `opener=` / `fs=` knobs above are **sync** \u2014 one read at a time. For workloads that fan out many concurrent reads from one process (a tile server serving S2 chips, an async ML inference service), `AsyncGeoTIFFReader` + `asyncio.gather` is the right shape. It is COG-only (good for the per-band JP2/TIFF granules; not for the SAFE XML metadata), takes any `obspec.AsyncStore` (`obstore.GCSStore` here), and skips GDAL entirely on the read path.\n",
+    "\n",
+    "Sketch (pseudocode \u2014 needs real bucket coordinates and credentials):\n",
+    "\n",
+    "```python\n",
+    "import asyncio\n",
+    "from obstore.store import GCSStore\n",
+    "from georeader.async_geotiff_reader import AsyncGeoTIFFReader\n",
+    "\n",
+    "# An obstore store rooted at the public Sentinel-2 GCS bucket\n",
+    "store = GCSStore(bucket=\"gcp-public-data-sentinel-2\", skip_signature=True)\n",
+    "\n",
+    "# One reader per granule; in tile-server use these are cached in an LRU.\n",
+    "reader = await AsyncGeoTIFFReader.open(\"path/to/B04.jp2\", store=store)\n",
+    "\n",
+    "# Fan out across N windows of one granule:\n",
+    "chips = await asyncio.gather(*[reader.read_from_window(w) for w in windows])\n",
+    "\n",
+    "# Or across N granules concurrently:\n",
+    "readers = await asyncio.gather(*[AsyncGeoTIFFReader.open(p, store=store) for p in paths])\n",
+    "scenes = await asyncio.gather(*[r.load() for r in readers])\n",
+    "```\n",
+    "\n",
+    "See [`advanced/async_geotiff_reader.ipynb`](advanced/async_geotiff_reader.ipynb) for the full tutorial, diagrams, and a mini-solution for warp-after-load.\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "d45f3f30-150e-487e-a8e6-93df89f542c8",
diff --git a/mkdocs.yml b/mkdocs.yml
index 431bde8..6f56be2 100644
--- a/mkdocs.yml
+++ b/mkdocs.yml
@@ -47,6 +47,7 @@ nav:
     - Advanced:
       - VSIL cache problem: advanced/error_read_write_in_remote_path.md
       - RasterioReader bytes-path knobs: advanced/bytes_path_knobs.ipynb
+      - AsyncGeoTIFFReader — async COG reads: advanced/async_geotiff_reader.ipynb
 plugins:
   - search
   # - social  # Disabled: requires mkdocs-material[imaging] with PIL and cairosvg
diff --git a/notebooks/read_from_tileserver.ipynb b/notebooks/read_from_tileserver.ipynb
index d5b7a4e..5521d47 100644
--- a/notebooks/read_from_tileserver.ipynb
+++ b/notebooks/read_from_tileserver.ipynb
@@ -4,7 +4,14 @@
    "cell_type": "code",
    "execution_count": 1,
    "id": "93ee315c-f757-49fe-9cd1-8e4dbfc86dff",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:11:57.849266Z",
+     "iopub.status.busy": "2026-05-14T16:11:57.848858Z",
+     "iopub.status.idle": "2026-05-14T16:11:57.926957Z",
+     "shell.execute_reply": "2026-05-14T16:11:57.926724Z"
+    }
+   },
    "outputs": [],
    "source": [
     "from shapely.geometry import shape, mapping\n",
@@ -19,9 +26,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 2,
    "id": "9fb94c53-6685-467d-9421-a74d66c1e78e",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:11:57.928357Z",
+     "iopub.status.busy": "2026-05-14T16:11:57.928262Z",
+     "iopub.status.idle": "2026-05-14T16:11:59.880855Z",
+     "shell.execute_reply": "2026-05-14T16:11:59.880537Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -30,15 +44,15 @@
        "         Transform: | 2.39, 0.00, 1087911.50|\n",
        "| 0.00,-2.39, 3261207.31|\n",
        "| 0.00, 0.00, 1.00|\n",
-       "         Shape: (3, 960, 955)\n",
+       "         Shape: (3, 961, 956)\n",
        "         Resolution: (2.388657134026289, 2.388657134026289)\n",
-       "         Bounds: (1087911.5029829773, 3258914.198852694, 1090192.670545863, 3261207.3097012495)\n",
+       "         Bounds: (1087911.502982975, 3258911.81019556, 1090195.0592029945, 3261207.3097012495)\n",
        "         CRS: EPSG:3857\n",
        "         fill_value_default: 0\n",
        "        "
       ]
      },
-     "execution_count": 3,
+     "execution_count": 2,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -53,9 +67,16 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "id": "bd0a8c19-4e9f-4196-9150-1b362a21a3fc",
-   "metadata": {},
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:11:59.882023Z",
+     "iopub.status.busy": "2026-05-14T16:11:59.881927Z",
+     "iopub.status.idle": "2026-05-14T16:12:00.716742Z",
+     "shell.execute_reply": "2026-05-14T16:12:00.716288Z"
+    }
+   },
    "outputs": [
     {
      "data": {
@@ -63,13 +84,13 @@
        "<Axes: >"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 3,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -85,6 +106,126 @@
     "plot.add_shape_to_plot(aoi, crs_plot=output.crs, crs_shape=\"EPSG:4326\", polygon_no_fill=True)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "e2ec990f",
+   "metadata": {},
+   "source": [
+    "## Async alternative — `AsyncGeoTIFFReader` against a public COG\n",
+    "\n",
+    "The tile-server example above reads stitched XYZ tiles via HTTP (the\n",
+    "common tile-server protocol). For COG sources — files written once and\n",
+    "served with HTTP range requests — `AsyncGeoTIFFReader` is the better\n",
+    "shape: same metadata surface as `RasterioReader`, but reads are coroutines\n",
+    "you can fan out with `asyncio.gather`.\n",
+    "\n",
+    "The two protocols are different (XYZ tiles ≠ COG windows), so this is\n",
+    "**not a 1:1 swap on the same input**. The cell below demonstrates the\n",
+    "equivalent shape against a real public COG — a Sentinel-2 L2A scene from\n",
+    "[Element 84's `sentinel-cogs` bucket](https://registry.opendata.aws/sentinel-2-l2a-cogs/)\n",
+    "(anonymously readable on AWS).\n",
+    "\n",
+    "Needs: `pip install georeader-spaceml[async] obstore`\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "d1d60b7b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:12:00.718507Z",
+     "iopub.status.busy": "2026-05-14T16:12:00.718373Z",
+     "iopub.status.idle": "2026-05-14T16:12:01.977361Z",
+     "shell.execute_reply": "2026-05-14T16:12:01.977055Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "CRS:       EPSG:32630\n",
+      "shape:     (1, 10980, 10980)\n",
+      "dtype:     uint16\n",
+      "overviews: 4\n"
+     ]
+    }
+   ],
+   "source": [
+    "import asyncio\n",
+    "\n",
+    "import rasterio.windows\n",
+    "from obstore.store import S3Store\n",
+    "\n",
+    "from georeader.async_geotiff_reader import AsyncGeoTIFFReader\n",
+    "\n",
+    "# Element 84's sentinel-cogs bucket is anonymously readable on AWS.\n",
+    "store = S3Store(bucket=\"sentinel-cogs\", region=\"us-west-2\", skip_signature=True)\n",
+    "\n",
+    "# A stable public S2 L2A scene (UTM zone 30, MGRS tile T-UM, May 2022).\n",
+    "scene_path = (\n",
+    "    \"sentinel-s2-l2a-cogs/30/T/UM/2022/5/S2A_30TUM_20220506_0_L2A/B04.tif\"\n",
+    ")\n",
+    "\n",
+    "# open() fetches only the COG header (cheap; small range request).\n",
+    "reader = await AsyncGeoTIFFReader.open(scene_path, store=store)\n",
+    "print(f\"CRS:       {reader.crs}\")\n",
+    "print(f\"shape:     {reader.shape}\")\n",
+    "print(f\"dtype:     {reader.dtype}\")\n",
+    "print(f\"overviews: {len(reader._geotiff.overviews)}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "11a7509b",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-14T16:12:01.980638Z",
+     "iopub.status.busy": "2026-05-14T16:12:01.980519Z",
+     "iopub.status.idle": "2026-05-14T16:12:10.410172Z",
+     "shell.execute_reply": "2026-05-14T16:12:10.409769Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Issued 16 concurrent reads from one process\n",
+      "All shapes correct: True\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Fan out 16 concurrent window reads from one process / one event loop /\n",
+    "# one S3Store. Each await is a coroutine; asyncio.gather schedules them\n",
+    "# all at once, the Rust core coalesces adjacent tile fetches inside each call.\n",
+    "windows = [\n",
+    "    rasterio.windows.Window(col_off=5000 + (i % 4) * 256,\n",
+    "                            row_off=5000 + (i // 4) * 256,\n",
+    "                            width=256, height=256)\n",
+    "    for i in range(16)\n",
+    "]\n",
+    "\n",
+    "chips = await asyncio.gather(*[reader.read_from_window(w) for w in windows])\n",
+    "\n",
+    "print(f\"Issued {len(windows)} concurrent reads from one process\")\n",
+    "print(f\"All shapes correct: {all(c.values.shape == (1, 256, 256) for c in chips)}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ced744f5",
+   "metadata": {},
+   "source": [
+    "See [`docs/advanced/async_geotiff_reader.ipynb`](../docs/advanced/async_geotiff_reader.ipynb)\n",
+    "for the full tutorial — the two-phase laziness model, overviews, the\n",
+    "post-load warp mini-solution, and the gotchas (TIFF/COG only, no warp,\n",
+    "not pickleable across processes).\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "988d043a-cc09-47aa-a5e8-16142dfc618f",
@@ -129,7 +270,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.12"
+   "version": "3.11.6"
   }
  },
  "nbformat": 4,

From ae7a4e92b01f056c5675a0256130f7c03dbea58f Mon Sep 17 00:00:00 2001
From: Juan Emmanuel Johnson <jemanjohnson34@gmail.com>
Date: Thu, 14 May 2026 18:20:51 +0200
Subject: [PATCH 5/7] chore: regenerate poetry.lock for new optional deps

CI's `poetry install --with dev,tutorial` fails because pyproject.toml gained
new entries (`async-geotiff` optional dep, `[async]` extra, `pytest-asyncio`
+ `obstore` + `async-geotiff` in dev) that are not reflected in poetry.lock.

Regenerated with Poetry 2.4.1 (matching CI's `version: latest`). Lockfile
format is preserved; only the new dep entries and their transitive closure
are added. Existing pins are unchanged.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 poetry.lock | 188 ++++++++++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 182 insertions(+), 6 deletions(-)

diff --git a/poetry.lock b/poetry.lock
index 5aa2885..8589243 100644
--- a/poetry.lock
+++ b/poetry.lock
@@ -1,4 +1,4 @@
-# This file is automatically @generated by Poetry 2.4.0 and should not be changed by hand.
+# This file is automatically @generated by Poetry 2.4.1 and should not be changed by hand.
 
 [[package]]
 name = "adlfs"
@@ -30,7 +30,7 @@ version = "2.4.0"
 description = "Matrices describing affine transformation of the plane"
 optional = false
 python-versions = ">=3.7"
-groups = ["main", "tutorial"]
+groups = ["main", "dev", "tutorial"]
 files = [
     {file = "affine-2.4.0-py3-none-any.whl", hash = "sha256:8a3df80e2b2378aef598a83c1392efd47967afec4242021a0b06b4c7cbc61a92"},
     {file = "affine-2.4.0.tar.gz", hash = "sha256:a24d818d6a836c131976d22f8c27b8d3ca32d0af64c1d8d29deb7bafa4da1eea"},
@@ -357,6 +357,29 @@ files = [
 astroid = ["astroid (>=2,<4)"]
 test = ["astroid (>=2,<4)", "pytest", "pytest-cov", "pytest-xdist"]
 
+[[package]]
+name = "async-geotiff"
+version = "0.5.0"
+description = "Async GeoTIFF reader for Python"
+optional = false
+python-versions = ">=3.11"
+groups = ["main", "dev"]
+files = [
+    {file = "async_geotiff-0.5.0-py3-none-any.whl", hash = "sha256:f596e91cb6da75ef28e8edc40d52ea53009e4d1bdc27123eed9d2a31a02adad2"},
+    {file = "async_geotiff-0.5.0.tar.gz", hash = "sha256:6c51b7c2f6e92083431d81611cd12706178d65f17e204a48fa05566a2d3261cb"},
+]
+markers = {main = "extra == \"async\""}
+
+[package.dependencies]
+affine = ">=2.4.0"
+async-tiff = ">=0.7.0"
+defusedxml = ">=0.7.1"
+numpy = ">=2.0"
+pyproj = ">=3.3.0"
+
+[package.extras]
+morecantile = ["morecantile (>=7.0,<8.0)"]
+
 [[package]]
 name = "async-lru"
 version = "2.0.5"
@@ -369,6 +392,44 @@ files = [
     {file = "async_lru-2.0.5.tar.gz", hash = "sha256:481d52ccdd27275f42c43a928b4a50c3bfb2d67af4e78b170e3e0bb39c66e5bb"},
 ]
 
+[[package]]
+name = "async-tiff"
+version = "0.7.2"
+description = ""
+optional = false
+python-versions = ">=3.10"
+groups = ["main", "dev"]
+files = [
+    {file = "async_tiff-0.7.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:7a5006bfcfccda9a7fe3b2178701dbd04e64eb7fea74c952c277d350c255af18"},
+    {file = "async_tiff-0.7.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c41fe8198001decfe66ce0d059711b175494915484b85a9bb3c8f2a98ab24350"},
+    {file = "async_tiff-0.7.2-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:0be9c8dd1cc08e7dbeeb04ed9e1bf2c0b96376c46fd13c3070cee92c5ae461de"},
+    {file = "async_tiff-0.7.2-cp310-cp310-manylinux_2_28_i686.whl", hash = "sha256:04c47f376ce9de160915d26a4e8b123572e3c01e74bee36b31cf2bfdff35c91a"},
+    {file = "async_tiff-0.7.2-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:243804a56a9b2d7af2e50cab6fdca443a829ab6b678c0e6c8ff78610c0098fdd"},
+    {file = "async_tiff-0.7.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:64fc6dd9459a63bf2fa55fe074bdb940d2889bc2467c528d56fb9bfba57a1be1"},
+    {file = "async_tiff-0.7.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d4f74d3ec990791b08af6992f0c16b64fea938805f8e26a4931d1ffd2d3d8f60"},
+    {file = "async_tiff-0.7.2-cp310-cp310-win_amd64.whl", hash = "sha256:ca3f521d7f3b9303424a141685396044003669f5acfbe10e58aceb10320a7e85"},
+    {file = "async_tiff-0.7.2-cp311-abi3-macosx_10_12_x86_64.whl", hash = "sha256:028e9d629dbe8d830581d8e46b92081a656953db020b424615af3c6e51ed9249"},
+    {file = "async_tiff-0.7.2-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:97d77fcad25824321645c3b83da060b1ece827f30e76fe64db74b4df97e5da1d"},
+    {file = "async_tiff-0.7.2-cp311-abi3-manylinux_2_28_aarch64.whl", hash = "sha256:62859389a21dc512f5c37fe17729eeeafb66c445374fcf888c1aa2c64bc79ff7"},
+    {file = "async_tiff-0.7.2-cp311-abi3-manylinux_2_28_i686.whl", hash = "sha256:1fb75527b4405107af587e55f4d34e50e8f2f8fe70bfac615e551fbe156cfe11"},
+    {file = "async_tiff-0.7.2-cp311-abi3-manylinux_2_28_x86_64.whl", hash = "sha256:84ca597d8a6354d7b1ae46d2c41432e0dad36ffd4ad54f45aa29d11857506e9b"},
+    {file = "async_tiff-0.7.2-cp311-abi3-musllinux_1_2_i686.whl", hash = "sha256:ed2ca1842f47714a23623125bb864b858db400f9b7af4cae41dfc04f798f2557"},
+    {file = "async_tiff-0.7.2-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:0cb8ec113b5d33ad020556527ae54f2cb86f7e955fedac718779a4b12404688f"},
+    {file = "async_tiff-0.7.2-cp311-abi3-win_amd64.whl", hash = "sha256:296647adac8b05ae1bacc69feea2e42ce17220d34df1bc419be0daa94364ebd5"},
+    {file = "async_tiff-0.7.2-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:e75dc8f806f60fe738cce85d5f03a014472db48ed4369b5ba03b185396d09772"},
+    {file = "async_tiff-0.7.2-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:49473e043083a532dd7f1210363e626f964e65be9ce68ed986a2645005ae0f0c"},
+    {file = "async_tiff-0.7.2-pp311-pypy311_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:43b1399633fa5839a705c43b3f01dc9d70de5dd422098130da34a904eb0f5600"},
+    {file = "async_tiff-0.7.2-pp311-pypy311_pp73-manylinux_2_28_i686.whl", hash = "sha256:1b6ab725e061c232e4f0a74cd2aa72024a4459f521deeedc807a82a1408b61e0"},
+    {file = "async_tiff-0.7.2-pp311-pypy311_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:ed74fc8a7368140d1ff56094513ee9e90ef150d83846710e9436e990d4df056b"},
+    {file = "async_tiff-0.7.2-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:3df1bf90c3fa40acc5eef42ca9d927467d4b34d5d1281d9779ec77396bd5a964"},
+    {file = "async_tiff-0.7.2-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:1609c254845ab6ddb2db02466fa0fdad5a7410fc24eb652e4ea44891216dd2d1"},
+    {file = "async_tiff-0.7.2.tar.gz", hash = "sha256:b2eb1f2671de4e331d1eaef1fd5bb3670e1f26ec7465115be488e60349f2dbce"},
+]
+markers = {main = "extra == \"async\""}
+
+[package.dependencies]
+obspec = ">=0.1.0"
+
 [[package]]
 name = "attrs"
 version = "25.3.0"
@@ -1345,11 +1406,12 @@ version = "0.7.1"
 description = "XML bomb protection for Python stdlib modules"
 optional = false
 python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*"
-groups = ["docs"]
+groups = ["main", "dev", "docs"]
 files = [
     {file = "defusedxml-0.7.1-py2.py3-none-any.whl", hash = "sha256:a352e7e428770286cc899e2542b6cdaedb2b4953ff269a210103ec58f6198a61"},
     {file = "defusedxml-0.7.1.tar.gz", hash = "sha256:1bb3032db185915b62d7c6209c5a8792be6a32ab2fedacc84e01b52c51aa3e69"},
 ]
+markers = {main = "extra == \"async\""}
 
 [[package]]
 name = "distlib"
@@ -4157,6 +4219,100 @@ rsa = ["cryptography (>=3.0.0)"]
 signals = ["blinker (>=1.4.0)"]
 signedtoken = ["cryptography (>=3.0.0)", "pyjwt (>=2.0.0,<3)"]
 
+[[package]]
+name = "obspec"
+version = "0.1.0"
+description = "Object storage interface definitions for Python."
+optional = false
+python-versions = ">=3.9"
+groups = ["main", "dev"]
+files = [
+    {file = "obspec-0.1.0-py3-none-any.whl", hash = "sha256:307f0fa2c2998b324ecf0eed6a2a89049a4c40c9b1fa2b5e1af28f0ee72136b3"},
+    {file = "obspec-0.1.0.tar.gz", hash = "sha256:b189781a53f82ef8d6abf0c9e77fd4c46ac9f244d5a91eb35ee61c2e2b204a4a"},
+]
+markers = {main = "extra == \"async\""}
+
+[package.dependencies]
+typing-extensions = {version = "*", markers = "python_version < \"3.12\""}
+
+[[package]]
+name = "obstore"
+version = "0.9.4"
+description = ""
+optional = false
+python-versions = ">=3.10"
+groups = ["dev"]
+files = [
+    {file = "obstore-0.9.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:caad50ef758d4342a2a772661fbcae2b4c6c3d242096910aa8d4614a40dee38c"},
+    {file = "obstore-0.9.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:36eb8e95efa63e0d01fbb6c56a7102d96ba0469278f4c6cc230f54871e1b3605"},
+    {file = "obstore-0.9.4-cp310-cp310-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:06881c82d0175d80bdd0a795ae2e4ed6b6c67437d8ddcdb670d3f5a6dee685cb"},
+    {file = "obstore-0.9.4-cp310-cp310-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:006573a9b69d91dbb73b491508b68dd5b8b5e4096d0ec825c8b8ee0b5b1364cc"},
+    {file = "obstore-0.9.4-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f4c4ede2313c865bac5f57198dbad8daa8779d7f4e63f92067f5f398d6341df4"},
+    {file = "obstore-0.9.4-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:35563432aa42be69c5e5aa47520aae6af398f8c33b599efeb96640e97a2b612c"},
+    {file = "obstore-0.9.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1723313902127d5df021203b0e90218636cbbf8954dbe845656bb0a6bc2d907e"},
+    {file = "obstore-0.9.4-cp310-cp310-manylinux_2_24_aarch64.whl", hash = "sha256:780a5aec49ca6c081af029250e4c20686e6236ccea42a489fccb689065391438"},
+    {file = "obstore-0.9.4-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:755781392c3e4bef90844c10749d2898ca10e10aab15c1c1cd6deef0e5145697"},
+    {file = "obstore-0.9.4-cp310-cp310-musllinux_1_2_armv7l.whl", hash = "sha256:5063221a224110c4cebc2a982d4049324f7c205b5b4334ed2d15cc63c541b790"},
+    {file = "obstore-0.9.4-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dbd0dde6436f0bfa97a219cd892f9681f2d20dfdf396a8239a318c75e565f342"},
+    {file = "obstore-0.9.4-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9206ebfd5fc594e038f2cbe2f7631a8b442a89f37ed5d14fd0bd31a10ff19281"},
+    {file = "obstore-0.9.4-cp310-cp310-win_amd64.whl", hash = "sha256:b23579c6901749e3507cb01c9fd4412eaf29e15a6c85441f124a223c183f0136"},
+    {file = "obstore-0.9.4-cp311-abi3-macosx_10_12_x86_64.whl", hash = "sha256:0d17cd04e7f22960050a85f8daa6e274d693e8fb3b97b81eeaa293c6f9e62eb4"},
+    {file = "obstore-0.9.4-cp311-abi3-macosx_11_0_arm64.whl", hash = "sha256:d4beec92710fb8826fb357baf28fb79a91ee07dcdfe73777207aa762164aaa35"},
+    {file = "obstore-0.9.4-cp311-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:d523c8c365ab60afb8d232614a00a92bea439a9f5c55b92486c23a47af038a1e"},
+    {file = "obstore-0.9.4-cp311-abi3-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ee0483619088337ee365cb344fceee337e2670ec4de2a1da92ac7f6b2220f18e"},
+    {file = "obstore-0.9.4-cp311-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:83da348bf0a7dd84e5839c0cd54d79dcd08e0729c394e566f73a605b93b9e998"},
+    {file = "obstore-0.9.4-cp311-abi3-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f282a17200bcc37b8d7a1d02a146ed41812eb6e76fd0a4c9a154f02da1b8031f"},
+    {file = "obstore-0.9.4-cp311-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d29dcfceaa0a205ded2263d29a2a3aa206819d549e0325c1f2106f79e2658584"},
+    {file = "obstore-0.9.4-cp311-abi3-manylinux_2_24_aarch64.whl", hash = "sha256:caecb912723ab8e9da8da26def249d66da4318959df2bafc0a55af64f3255902"},
+    {file = "obstore-0.9.4-cp311-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:0c1c06fec8837595a2829b5f7536d0d01e940ce10b07ad2a8594fec1cfd0b7d5"},
+    {file = "obstore-0.9.4-cp311-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:c132795a789ec5ade31bf4d5b55ed321fb41d9749e9145520bf19063e1da5f7b"},
+    {file = "obstore-0.9.4-cp311-abi3-musllinux_1_2_i686.whl", hash = "sha256:c6e342360a5d0ae71486bc5f8311778aa144ec1a905c23593f8ef57b5bceae24"},
+    {file = "obstore-0.9.4-cp311-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:aeb6f7e7e862550f5020a10692ef6f02d5ba4912dba08942eb59bb7d73f93fe0"},
+    {file = "obstore-0.9.4-cp311-abi3-win_amd64.whl", hash = "sha256:a58ef942292841f99d69ac11d19d05544c835447c8c09dacbfb7409c6374c4a1"},
+    {file = "obstore-0.9.4-cp313-cp313t-macosx_10_12_x86_64.whl", hash = "sha256:fff17f59390ed307afcd1fb18c56076c1f911dd9f5c2636b7d7133c4d07f8c3f"},
+    {file = "obstore-0.9.4-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:4527c4c7889f1bd1f1952017d74774870e14e199d6b50b9e72f291f9498d898c"},
+    {file = "obstore-0.9.4-cp313-cp313t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:a57c2016e3e569de35050f95c679ffe61813c4e3cb6d6028c4c3f57231021eb4"},
+    {file = "obstore-0.9.4-cp313-cp313t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd5327cee4fb3578b51beb1c92915cc3a05ffe794be40f50bd68d27e97d78c5c"},
+    {file = "obstore-0.9.4-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:12b1e6105eafe02d8973dbeb2d274eeac2271c67f1126ffa16f18ddea8dd5443"},
+    {file = "obstore-0.9.4-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:0b0d378248fda4e36652808d73eaaeb7e67154427e6c724248c9b0b9b03e70a6"},
+    {file = "obstore-0.9.4-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a78fb77c346abd2bcdfa071d7166be2bdc38c28573ae5a230746df6158a5593e"},
+    {file = "obstore-0.9.4-cp313-cp313t-manylinux_2_24_aarch64.whl", hash = "sha256:f4e5a6dfe6877fb599868d560d6fcf4d7416cadbdf3bd947254b53830c2f11c0"},
+    {file = "obstore-0.9.4-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:f8114a2b84268c991232d89b105d9239299b6afb56e4941a61c09f3a89033022"},
+    {file = "obstore-0.9.4-cp313-cp313t-musllinux_1_2_armv7l.whl", hash = "sha256:9d7b959f5f74532a142fb449c0bef5814dfe3fa5c43c31ac4284a15221a75aaf"},
+    {file = "obstore-0.9.4-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:a8e9101fc2659dd938e7ae06512075bc0a8f02ab28d2ee438d6fca8b4f3bdfba"},
+    {file = "obstore-0.9.4-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:538384255545b5c575497fcab26389c8f01707402b6ddcdd73b769b66311635d"},
+    {file = "obstore-0.9.4-cp313-cp313t-win_amd64.whl", hash = "sha256:eef1c772657bb1293adad0d671ca1ff1e1dcae84ec4dfbf1a34e47c2a1f134ac"},
+    {file = "obstore-0.9.4-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:e009e7437770c85beae4c32cb79f662f0a9922676ef127e943d107a5c082d38d"},
+    {file = "obstore-0.9.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:ac5f3ad314bd4592fe484b79c229518be7bb5f6218bed33c20742026d5caf860"},
+    {file = "obstore-0.9.4-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:db79d5ebc4177360565ffcec4abd49930cf052cdbeb94e3a3ece2e2d08f087d0"},
+    {file = "obstore-0.9.4-cp314-cp314t-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:05b565d89c3115fb74385852dd628e12f6645a1bba97523dceae016b538a3f33"},
+    {file = "obstore-0.9.4-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7dfc4fc98403d8fbb316eb04257c8122b6f1dda37e80869491fdacf60a815e4c"},
+    {file = "obstore-0.9.4-cp314-cp314t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c69af620fd3d06a8cfb62d25faf1adb6ccc97cc572f47ee04dddcde5a5e5444e"},
+    {file = "obstore-0.9.4-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fa78c0230e0b9d49b25ed18980e1751331ddfe05782d6ce97579a9ccda8229ea"},
+    {file = "obstore-0.9.4-cp314-cp314t-manylinux_2_24_aarch64.whl", hash = "sha256:c828719f0bb310a9cf0e0f08cb62a0b8cc550138617cb03ac897900aec9d3d47"},
+    {file = "obstore-0.9.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:49a0455519f284b6bc2e0694298114926aff1d1f3d5d344e9163e03b446826cc"},
+    {file = "obstore-0.9.4-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cf437309fc0fe852591ae50405300490229f876ea06574651fd753ca3fd23f25"},
+    {file = "obstore-0.9.4-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:d83dbd20b6a5d42e35794ef64046de39040854829ec4f1eb2f6dfb54df48cc3d"},
+    {file = "obstore-0.9.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5a0c337f37f30a2d66555d69bf3abd840457a279c57ede93bd02e014721ed364"},
+    {file = "obstore-0.9.4-cp314-cp314t-win_amd64.whl", hash = "sha256:24e37a1c713c95a964e119f8ef879415a495432162e74e80ed29d645aeeca114"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c7bb85a892d5f1ac5a24170fc26068eec5e4cc46b11689af5058c033e494c1af"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:704d83e5d94e3c9b8c84d33a9d302e9c5110cdbeba3ff27c859e864b03e44fc1"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:7f1b3626429fc223ed4b7355c444587d0c328a0126d81812f4f54984526fbf66"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:78000bda795dccc6f48b2e743be3a92ed1e2933b974439f3dbb3549f9038668b"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:31590b64afe19d13f1b668b35900519810881636cea05366f3790b96d5881a6a"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4f42cde6f3424ef02e9bfe50ca21d1b0ae6c313b12515a45d5c2bb3e6de9bd20"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c228b545925510bef514ff2f954231a985ab1ef21c02e7c7ac448b3cc55c6377"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-manylinux_2_24_aarch64.whl", hash = "sha256:b99f5a681ad4dafe7ce21fbfff225a96522ce5a79c0f9042b57db31a530ab216"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-musllinux_1_2_aarch64.whl", hash = "sha256:8e63a7bdf69efdb49b2081daf11144e226eafa20606d3993e97ea0729c5c5cb7"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-musllinux_1_2_armv7l.whl", hash = "sha256:2acaa282058d2f1bcffe1ec4ba7cd74746fc498fa400d5887579fdb155d16f39"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-musllinux_1_2_i686.whl", hash = "sha256:1fc897945bd6d0eb0de1044c71bec8c961fa4f176453d28421c80a11e37f00ae"},
+    {file = "obstore-0.9.4-pp311-pypy311_pp73-musllinux_1_2_x86_64.whl", hash = "sha256:7c39e3575796a712cbf437197404975d7d5e3f046f9bd6580a76be7f46b2ade6"},
+    {file = "obstore-0.9.4.tar.gz", hash = "sha256:e2b93f1372c59da2c7e74122fc6dc4b713d84fd4528b5b500ef7f548425496b5"},
+]
+
+[package.dependencies]
+typing-extensions = {version = "*", markers = "python_full_version < \"3.13.0\""}
+
 [[package]]
 name = "overrides"
 version = "7.7.0"
@@ -5115,7 +5271,7 @@ version = "3.7.2"
 description = "Python interface to PROJ (cartographic projections and coordinate transformations library)"
 optional = false
 python-versions = ">=3.11"
-groups = ["main"]
+groups = ["main", "dev"]
 files = [
     {file = "pyproj-3.7.2-cp311-cp311-macosx_13_0_x86_64.whl", hash = "sha256:2514d61f24c4e0bb9913e2c51487ecdaeca5f8748d8313c933693416ca41d4d5"},
     {file = "pyproj-3.7.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:8693ca3892d82e70de077701ee76dd13d7bca4ae1c9d1e739d72004df015923a"},
@@ -5271,6 +5427,25 @@ pluggy = ">=0.12,<2.0"
 [package.extras]
 testing = ["argcomplete", "attrs (>=19.2.0)", "hypothesis (>=3.56)", "mock", "nose", "pygments (>=2.7.2)", "requests", "setuptools", "xmlschema"]
 
+[[package]]
+name = "pytest-asyncio"
+version = "0.23.8"
+description = "Pytest support for asyncio"
+optional = false
+python-versions = ">=3.8"
+groups = ["dev"]
+files = [
+    {file = "pytest_asyncio-0.23.8-py3-none-any.whl", hash = "sha256:50265d892689a5faefb84df80819d1ecef566eb3549cf915dfb33569359d1ce2"},
+    {file = "pytest_asyncio-0.23.8.tar.gz", hash = "sha256:759b10b33a6dc61cce40a8bd5205e302978bbbcc00e279a8b61d9a6a3c82e4d3"},
+]
+
+[package.dependencies]
+pytest = ">=7.0.0,<9"
+
+[package.extras]
+docs = ["sphinx (>=5.3)", "sphinx-rtd-theme (>=1.0)"]
+testing = ["coverage (>=6.2)", "hypothesis (>=5.7.1)"]
+
 [[package]]
 name = "python-dateutil"
 version = "2.9.0.post0"
@@ -6465,7 +6640,7 @@ files = [
     {file = "typing_extensions-4.15.0-py3-none-any.whl", hash = "sha256:f0fa19c6845758ab08074a0cfa8b7aecb71c999ca73d62883bc25cc018c4e548"},
     {file = "typing_extensions-4.15.0.tar.gz", hash = "sha256:0cea48d173cc12fa28ecabc3b837ea3cf6f38c6d1136f85cbaaf598984861466"},
 ]
-markers = {main = "extra == \"carbonmapper\""}
+markers = {main = "extra == \"carbonmapper\" or python_version == \"3.11\" and (extra == \"async\" or extra == \"carbonmapper\")"}
 
 [[package]]
 name = "typing-inspection"
@@ -6919,9 +7094,10 @@ multidict = ">=4.0"
 propcache = ">=0.2.1"
 
 [extras]
+async = ["async-geotiff"]
 carbonmapper = ["pydantic", "requests"]
 
 [metadata]
 lock-version = "2.1"
 python-versions = ">=3.11,<4.0"
-content-hash = "c6a30b3acc564b2d326e9ee3515de5c2a8af467dd6d6abe8ed7de5a0bab3611e"
+content-hash = "ee9ab7f2c9a61f7cadfd54ddc8b0aa25db2e46d5e7b6f2f78612cf91b007da17"

From fcde09948377c434bc28cda01507e865bcda9f9d Mon Sep 17 00:00:00 2001
From: Juan Emmanuel Johnson <jemanjohnson34@gmail.com>
Date: Mon, 18 May 2026 07:42:11 +0200
Subject: [PATCH 6/7] feat(async_geotiff_reader): polymorphic lazy-view pattern
 + overviews/block_windows parity
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Restructure AsyncGeoTIFFReader to mirror RasterioReader's laziness pattern:
read_from_window is now sync and returns a windowed AsyncGeoTIFFReader view
(no I/O); load() is async and performs the actual fetch. This makes the
reader work polymorphically with the entire read.* module — read_from_window,
read_from_bounds, read_from_polygon, read_from_center_coords, read_from_tile,
and read_reproject(_like) — the latter via the pre-load pattern
(`await reader.load()` then pass the GeoTensor; isinstance(data_in, GeoTensor)
short-circuit at read.py:1605 skips internal sync materialisation).

New methods matching RasterioReader:
- overviews() / reader_overview(level): introspect and pin overview level
- block_windows(): tile-aligned iteration for fan-out reads aligned with
  the COG's internal tile grid

Other reader changes:
- window_focus attribute tracks the current view's window
- _raster_window property replaces three inline Window(0, 0, w, h)
  constructions (parallels RasterioReader.real_window)
- fill_value_default falls back to 0 when the COG has no nodata tag
  (matches RasterioReader's nodata-if-not-none-else-0 default)
- Boundless padding routed through window_utils.get_slice_pad +
  GeoTensor.pad() (same pattern as GeoTensor.read_from_window) — replaces
  the previous bespoke np.full + offset-placement code
- Rich __repr__ when opened; aligned multi-line Affine formatting (also
  fixed in RasterioReader.__repr__)

Protocol:
- AsyncGeoData.read_from_window is sync now (returns view), aligning with
  GeoData.read_from_window. Only load() remains async.

Tests (suite: 926 passed, 0 skipped, 0 failed; was 793):
- AsyncGeoTIFFReader: 19 reader-specific tests — overviews, reader_overview,
  block_windows, nested views, explicit nodata, focused bounds,
  read-before-open, boundless edge windows, concurrent fan-out
- New cog_with_nodata_and_overviews fixture for paths the default fixture
  doesn't reach
- test_read_dataarray.py parametrized across both readers via a
  reader_and_materialize fixture — covers all read.* functions including
  read_reproject(_like) via the pre-load pattern (no aread_* siblings
  needed)
- New polymorphic coverage: cross-CRS bounds, cross-CRS polygon, pad_add,
  return_only_data (sync-only by design)

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 georeader/abstract_reader.py       |  18 +-
 georeader/async_geotiff_reader.py  | 310 +++++++++++++++----
 georeader/rasterio_reader.py       |  27 +-
 tests/test_abstract_reader.py      |  23 +-
 tests/test_async_geotiff_reader.py | 340 +++++++++++++++++++--
 tests/test_read_dataarray.py       | 473 +++++++++++++++++++++++++----
 6 files changed, 1016 insertions(+), 175 deletions(-)

diff --git a/georeader/abstract_reader.py b/georeader/abstract_reader.py
index 54cdb42..67ee6c9 100644
--- a/georeader/abstract_reader.py
+++ b/georeader/abstract_reader.py
@@ -259,9 +259,11 @@ class AsyncGeoData(GeoDataBase):
 
     Inherits the metadata surface and derived properties (``transform``,
     ``crs``, ``shape``, ``width``, ``height``, ``bounds``, ``res``,
-    ``footprint``) from :class:`GeoDataBase`. Adds ``async`` read methods
-    (``load``, ``read_from_window``) and the read-tier metadata
-    properties (``dtype``, ``dims``, ``fill_value_default``).
+    ``footprint``) from :class:`GeoDataBase`. Adds an ``async`` ``load``
+    method, a **sync** ``read_from_window`` that returns a windowed view
+    (mirroring :class:`~georeader.rasterio_reader.RasterioReader`), and
+    the read-tier metadata properties (``dtype``, ``dims``,
+    ``fill_value_default``).
 
     Notes
     -----
@@ -269,6 +271,14 @@ class AsyncGeoData(GeoDataBase):
     materialises via a sync ``self.load()``). Properties cannot be ``async``,
     so callers materialise via ``await reader.load()`` and read
     ``.values`` on the returned :class:`~georeader.geotensor.GeoTensor`.
+
+    ``read_from_window`` is **sync** by design: like
+    :meth:`RasterioReader.read_from_window`, it only constructs a windowed
+    view of the reader and performs no I/O. This means
+    :func:`georeader.read.read_from_window` (and other ``read.*``
+    functions) work polymorphically with both sync and async readers —
+    the only difference is that the returned async view must be
+    materialised via ``await view.load()``.
     """
 
     async def load(self, boundless: bool = True) -> GeoTensor:
@@ -276,7 +286,7 @@ async def load(self, boundless: bool = True) -> GeoTensor:
             "load method must be implemented in the subclass"
         )
 
-    async def read_from_window(
+    def read_from_window(
         self, window: rasterio.windows.Window, boundless: bool = True
     ) -> Union["AsyncGeoData", GeoTensor]:
         raise NotImplementedError(
diff --git a/georeader/async_geotiff_reader.py b/georeader/async_geotiff_reader.py
index 5c58724..1d119db 100644
--- a/georeader/async_geotiff_reader.py
+++ b/georeader/async_geotiff_reader.py
@@ -56,12 +56,17 @@
 
 `async-geotiff explicitly disclaims <https://github.com/developmentseed/async-geotiff#anti-features>`_
 warping, resampling, and automatic overview selection. This reader follows
-suit: ``read_bounds(target_crs=...)`` raises :class:`NotImplementedError`. For
-cross-CRS reads, either fetch in the native CRS and post-warp via
+suit. For cross-CRS reads, either fetch in the native CRS and post-warp via
 :func:`georeader.read.read_reproject_like`, or use
 :class:`~georeader.rasterio_reader.RasterioReader` (which has WarpedVRT
 integration on the sync path).
 
+Read by bounds / polygon / center / tile is provided by the
+:mod:`georeader.read` module functions, which work with any
+:class:`~georeader.abstract_reader.AsyncGeoData` (and
+:class:`~georeader.abstract_reader.GeoData`) input — this reader only
+implements the primitive ``read_from_window``.
+
 See Also
 --------
 georeader.abstract_reader.AsyncGeoData : Protocol satisfied by this reader.
@@ -76,18 +81,16 @@
 """
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any, Optional, Tuple, Union
+from typing import Any, Optional, Tuple
 
 import numpy as np
 import rasterio.windows
+from rasterio import Affine
 
 from georeader import window_utils
 from georeader.abstract_reader import AsyncGeoData
 from georeader.geotensor import GeoTensor
 
-if TYPE_CHECKING:
-    from rasterio import Affine
-
 try:
     from async_geotiff import GeoTIFF, RasterArray
     from async_geotiff import Window as _AGTWindow
@@ -120,6 +123,13 @@ class AsyncGeoTIFFReader(AsyncGeoData):
     async ``open()`` classmethod (or use the ``async with`` context manager)
     to perform the IFD fetch before reading metadata properties.
 
+    Mirrors :class:`~georeader.rasterio_reader.RasterioReader`'s
+    laziness pattern: :meth:`read_from_window` is **sync** and only
+    constructs a windowed view (no I/O); :meth:`load` is async and
+    performs the actual fetch. The :attr:`window_focus` attribute holds
+    the current view's window in absolute pixel coordinates relative to
+    the chosen ``overview_level``.
+
     Args:
         path_or_url: Path or URL relative to the ``store``. For local stores,
             this is the filename inside the store's ``prefix``; for cloud
@@ -130,6 +140,10 @@ class AsyncGeoTIFFReader(AsyncGeoData):
         overview_level: Which overview to read from. ``None`` (default)
             reads at full resolution from the primary IFD. An integer
             ``i`` reads from ``geotiff.overviews[i]`` (0-based).
+        window_focus: Initial window focus in absolute pixel coordinates
+            against the chosen overview level. ``None`` (default) means
+            the full extent. Mostly internal — produced by
+            :meth:`read_from_window`.
     """
 
     def __init__(
@@ -138,12 +152,14 @@ def __init__(
         *,
         store: Any,
         overview_level: Optional[int] = None,
+        window_focus: Optional[rasterio.windows.Window] = None,
     ) -> None:
         _require_async_geotiff()
         self.path_or_url = path_or_url
         self._store = store
         self._overview_level = overview_level
         self._geotiff: Optional[Any] = None
+        self.window_focus: Optional[rasterio.windows.Window] = window_focus
 
     @classmethod
     async def open(
@@ -190,24 +206,50 @@ def _level(self) -> Any:
             return gt
         return gt.overviews[self._overview_level]
 
+    @property
+    def _raster_window(self) -> rasterio.windows.Window:
+        """Full-extent window at the current overview level.
+
+        Counterpart to :attr:`RasterioReader.real_window`. Computed
+        per-access rather than cached because the level resolves
+        lazily (the IFD handle is shared across overview-pinned views).
+        """
+        level = self._level
+        return rasterio.windows.Window(
+            col_off=0, row_off=0, width=level.width, height=level.height,
+        )
+
     # ------------------------------------------------------------------ metadata
     @property
     def crs(self) -> Any:
         return self._require_open().crs
 
     @property
-    def transform(self) -> "Affine":
-        return self._level.transform
+    def transform(self) -> Affine:
+        """Affine transform of the current view.
+
+        When :attr:`window_focus` is set, returns the transform shifted
+        to the focus window's origin (matches
+        :class:`~georeader.rasterio_reader.RasterioReader`).
+        """
+        level_transform = self._level.transform
+        if self.window_focus is None:
+            return level_transform
+        return rasterio.windows.transform(self.window_focus, level_transform)
 
     @property
     def shape(self) -> Tuple[int, int, int]:
         """Returns ``(count, height, width)``.
 
+        Reflects the focused window size when :attr:`window_focus` is set.
         Note ``async_geotiff.GeoTIFF.shape`` is just ``(height, width)``;
         the band count lives on ``.count``.
         """
-        level = self._level
-        return (self._require_open().count, level.height, level.width)
+        bands = self._require_open().count
+        if self.window_focus is None:
+            level = self._level
+            return (bands, level.height, level.width)
+        return (bands, int(self.window_focus.height), int(self.window_focus.width))
 
     @property
     def dtype(self) -> Any:
@@ -216,26 +258,111 @@ def dtype(self) -> Any:
 
     @property
     def fill_value_default(self) -> Any:
-        return self._require_open().nodata
+        """Default fill value for out-of-bounds reads.
+
+        Returns the COG's nodata value when set, else ``0`` — matches
+        :class:`~georeader.rasterio_reader.RasterioReader`'s default
+        (``nodata if not None else 0``) so the read module's
+        no-intersection / boundless padding branches behave
+        consistently across sync and async readers.
+        """
+        nodata = self._require_open().nodata
+        return nodata if nodata is not None else 0
 
     @property
     def dims(self) -> list[str]:
         return ["band", "y", "x"]
 
     # --------------------------------------------------------------------- reads
-    async def read_from_window(
+    def read_from_window(
         self,
         window: rasterio.windows.Window,
         boundless: bool = True,
-    ) -> GeoTensor:
-        """Read a window. Returns a fresh :class:`GeoTensor`.
+    ) -> "AsyncGeoTIFFReader":
+        """Return a new windowed view of this reader. **Sync, no I/O.**
+
+        Mirrors :meth:`RasterioReader.read_from_window`: the returned
+        reader shares the underlying ``async-geotiff`` handle and only
+        carries a different :attr:`window_focus`. Call ``await
+        view.load()`` to materialise.
+
+        ``window`` is interpreted relative to the current
+        :attr:`window_focus` (matches
+        :meth:`RasterioReader.set_window` with ``relative=True``).
+        ``boundless=False`` intersects the resolved window with the
+        underlying raster extent and raises :class:`WindowError` if the
+        intersection is empty; ``boundless=True`` permits the focus
+        window to extend past the raster (padding is applied later in
+        :meth:`load`).
+        """
+        self._require_open()
+        # Translate the requested window from view-local to absolute coords.
+        if self.window_focus is None:
+            abs_window = window
+        else:
+            abs_window = rasterio.windows.Window(
+                col_off=window.col_off + self.window_focus.col_off,
+                row_off=window.row_off + self.window_focus.row_off,
+                width=window.width,
+                height=window.height,
+            )
+
+        if not boundless:
+            # Raises WindowError if the windows are disjoint — same
+            # contract as RasterioReader.set_window(..., boundless=False).
+            abs_window = rasterio.windows.intersection(abs_window, self._raster_window)
+
+        view = AsyncGeoTIFFReader(
+            self.path_or_url,
+            store=self._store,
+            overview_level=self._overview_level,
+            window_focus=abs_window,
+        )
+        view._geotiff = self._geotiff  # share the cached IFD handle
+        return view
+
+    async def load(self, boundless: bool = True) -> GeoTensor:
+        """Materialise the current view as a :class:`GeoTensor`.
+
+        Reads from :attr:`window_focus` (full extent when ``None``).
+        Follows the library padding pattern from
+        :meth:`GeoTensor.read_from_window`:
+        :func:`window_utils.get_slice_pad` -> async fetch -> ``.pad()``.
+
+        ``boundless=True`` pads up to the focused window's shape with
+        :attr:`fill_value_default` (or ``0`` when the COG has no
+        nodata); ``boundless=False`` returns the clipped intersection.
 
-        The ``boundless`` argument is accepted for protocol parity with
-        :meth:`georeader.abstract_reader.GeoData.read_from_window` but
-        ignored: async-geotiff's :meth:`read` already returns the requested
-        window region with the appropriate fill where data is missing.
+        Raises:
+            rasterio.windows.WindowError: If the focused window does not
+                intersect the raster at all (regardless of ``boundless``).
         """
-        del boundless  # accepted for protocol parity, see docstring
+        raster_window = self._raster_window
+        target_window = self.window_focus if self.window_focus is not None else raster_window
+
+        if boundless:
+            slice_dict, pad_width = window_utils.get_slice_pad(raster_window, target_window)
+            inner_window = rasterio.windows.Window.from_slices(
+                slice_dict["y"], slice_dict["x"],
+            )
+            inner_gt = await self._fetch_window(inner_window)
+            if any(p != 0 for p in pad_width["x"] + pad_width["y"]):
+                # Fall back to 0 when the COG has no explicit nodata —
+                # matches rasterio's C-level boundless padding default.
+                fill = self.fill_value_default if self.fill_value_default is not None else 0
+                inner_gt = inner_gt.pad(
+                    pad_width=pad_width,
+                    mode="constant",
+                    constant_values=fill,
+                )
+            return inner_gt
+
+        # boundless=False: clip to the intersection. WindowError on disjoint.
+        inner_window = rasterio.windows.intersection(target_window, raster_window)
+        return await self._fetch_window(inner_window)
+
+    async def _fetch_window(self, window: rasterio.windows.Window) -> GeoTensor:
+        """Read a fully-in-bounds window directly from async-geotiff."""
         agt_window = _AGTWindow(
             col_off=int(window.col_off),
             row_off=int(window.row_off),
@@ -243,45 +370,102 @@ async def read_from_window(
             height=int(window.height),
         )
         arr: Any = await self._level.read(window=agt_window)
-        return _rasterarray_to_geotensor(arr, fill_value=self.fill_value_default, crs=self.crs)
+        return _rasterarray_to_geotensor(
+            arr, fill_value=self.fill_value_default, crs=self.crs,
+        )
 
-    async def read_from_bounds(
-        self,
-        bounds: Tuple[float, float, float, float],
-        *,
-        target_resolution: Optional[Tuple[float, float]] = None,
-        target_crs: Any = None,
-    ) -> GeoTensor:
-        """Read by geographic bounds in the reader's native CRS.
-
-        Raises :class:`NotImplementedError` if ``target_resolution`` or
-        ``target_crs`` are set — this reader does not warp or resample (the
-        underlying ``async-geotiff`` explicitly disclaims warp). For
-        cross-CRS reads, either fetch in the native CRS and post-warp via
-        :func:`georeader.read.read_reproject_like`, or use
-        :class:`~georeader.rasterio_reader.RasterioReader`.
-        """
-        if target_crs is not None or target_resolution is not None:
-            raise NotImplementedError(
-                "AsyncGeoTIFFReader does not warp or resample. "
-                "Read in the native CRS, then call georeader.read.read_reproject_like, "
-                "or use RasterioReader for WarpedVRT-based on-the-fly warping."
-            )
-        win = window_utils.window_from_bounds(self, bounds)
-        return await self.read_from_window(win)
+    # ------------------------------------------------------ overviews & blocks
+    def overviews(self) -> list[int]:
+        """Return decimation factors for available overviews.
 
-    async def load(self, boundless: bool = True) -> GeoTensor:
-        """Read the whole raster (at the current ``overview_level``).
+        Mirrors :meth:`RasterioReader.overviews` — e.g. ``[2, 4, 8]``
+        means overviews exist at 1/2, 1/4, 1/8 of the primary IFD's
+        resolution. Empty list if the COG has no overviews.
 
-        ``boundless`` is accepted for protocol parity but ignored — the full
-        extent is always inside the raster's bounds.
+        Factors are computed from the full-resolution width divided by
+        each overview's width (rounded), since ``async-geotiff`` exposes
+        the overview IFDs directly rather than a factor list.
         """
-        del boundless
-        level = self._level
-        full_window = rasterio.windows.Window(
-            col_off=0, row_off=0, width=level.width, height=level.height,
+        gt = self._require_open()
+        full_width = gt.width
+        return [int(round(full_width / ov.width)) for ov in gt.overviews]
+
+    def reader_overview(self, overview_level: int) -> "AsyncGeoTIFFReader":
+        """Return a new reader pinned to a specific overview level.
+
+        Mirrors :meth:`RasterioReader.reader_overview`. The new reader
+        shares the underlying ``async-geotiff`` handle (no re-open) and
+        resets :attr:`window_focus` — converting a focus across
+        resolutions is non-trivial and matches the parent's TODO.
+
+        Args:
+            overview_level: Overview index. ``0`` is the first overview
+                (finest after full res); negative indexes count from the
+                end (``-1`` is the coarsest overview, not full res — same
+                convention as :meth:`RasterioReader.reader_overview`).
+        """
+        gt = self._require_open()
+        if overview_level < 0:
+            overview_level = len(gt.overviews) + overview_level
+
+        view = AsyncGeoTIFFReader(
+            self.path_or_url,
+            store=self._store,
+            overview_level=overview_level,
         )
-        return await self.read_from_window(full_window)
+        view._geotiff = self._geotiff
+
+        if self.window_focus is not None:
+            import warnings
+            warnings.warn(
+                "window_focus is not preserved across overview levels — "
+                "returning the overview at full extent.",
+                stacklevel=2,
+            )
+        return view
+
+    def block_windows(
+        self, bidx: int = 1,
+    ) -> list[tuple[tuple[int, int], rasterio.windows.Window]]:
+        """Return the internal COG tile windows at the current overview level.
+
+        Mirrors :meth:`RasterioReader.block_windows`. The returned
+        windows are tile-aligned in pixel coordinates relative to the
+        current overview level; the last row/column may be smaller than
+        ``(tile_height, tile_width)`` if the raster size isn't an exact
+        multiple. When :attr:`window_focus` is set, only blocks that
+        intersect the focus are returned, and each is clipped to the
+        focus extent (matches the parent's behavior).
+
+        Critical for tile-aligned async fan-out — reading non-aligned
+        windows triggers partial-tile fetches inside ``async-geotiff``
+        and wastes bytes over the wire.
+
+        Args:
+            bidx: Band index. Accepted for API parity with
+                :meth:`RasterioReader.block_windows`; ignored because
+                COG tiling is uniform across bands.
+        """
+        del bidx  # COG tile grid is uniform across bands
+        level = self._level
+        tile_w = level.tile_width
+        tile_h = level.tile_height
+        out: list[tuple[tuple[int, int], rasterio.windows.Window]] = []
+
+        for row_idx, row_off in enumerate(range(0, level.height, tile_h)):
+            for col_idx, col_off in enumerate(range(0, level.width, tile_w)):
+                width = min(tile_w, level.width - col_off)
+                height = min(tile_h, level.height - row_off)
+                block = rasterio.windows.Window(
+                    col_off=col_off, row_off=row_off, width=width, height=height,
+                )
+                if self.window_focus is not None:
+                    if not rasterio.windows.intersect([self.window_focus, block]):
+                        continue
+                    block = rasterio.windows.intersection(self.window_focus, block)
+                out.append(((row_idx, col_idx), block))
+
+        return out
 
     # -------------------------------------------------------------- lifecycle
     async def aclose(self) -> None:
@@ -297,10 +481,24 @@ async def __aexit__(self, *exc: Any) -> None:
         await self.aclose()
 
     def __repr__(self) -> str:
-        status = "opened" if self._geotiff is not None else "unopened"
+        if self._geotiff is None:
+            return (
+                f"AsyncGeoTIFFReader(path_or_url={self.path_or_url!r}, "
+                f"overview_level={self._overview_level!r}, unopened)"
+            )
+        # Layout mirrors RasterioReader.__repr__ for consistency.
+        transform_indent = "\n" + " " * 29
+        transform_str = transform_indent.join(str(self.transform).splitlines())
         return (
-            f"AsyncGeoTIFFReader(path_or_url={self.path_or_url!r}, "
-            f"overview_level={self._overview_level!r}, {status})"
+            "\n"
+            f"         path_or_url:        {self.path_or_url}\n"
+            f"         overview_level:     {self._overview_level}\n"
+            f"         Shape:              {self.shape}\n"
+            f"         Resolution:         {self.res}\n"
+            f"         Bounds:             {self.bounds}\n"
+            f"         CRS:                {self.crs}\n"
+            f"         fill_value_default: {self.fill_value_default}\n"
+            f"         Transform:          {transform_str}\n"
         )
 
 
diff --git a/georeader/rasterio_reader.py b/georeader/rasterio_reader.py
index 5d08e35..6b75a56 100644
--- a/georeader/rasterio_reader.py
+++ b/georeader/rasterio_reader.py
@@ -1268,17 +1268,22 @@ def meshgrid(self, dst_crs:Optional[Any]=None) -> Tuple[NDArray, NDArray]:
         from georeader import griddata
         return griddata.meshgrid(self.transform, self.width, self.height, source_crs=self.crs, dst_crs=dst_crs)
     
-    def __repr__(self)->str:
-        return f""" 
-         Paths: {self.paths}
-         Transform: {self.transform}
-         Shape: {self.shape}
-         Resolution: {self.res}
-         Bounds: {self.bounds}
-         CRS: {self.crs}
-         nodata: {self.nodata}
-         fill_value_default: {self.fill_value_default}
-        """
+    def __repr__(self) -> str:
+        # Continuation indent aligns multi-line Affine repr under the
+        # value column (9-space indent + 18-char label + ": ").
+        transform_indent = "\n" + " " * 29
+        transform_str = transform_indent.join(str(self.transform).splitlines())
+        return (
+            "\n"
+            f"         Paths:              {self.paths}\n"
+            f"         Shape:              {self.shape}\n"
+            f"         Resolution:         {self.res}\n"
+            f"         Bounds:             {self.bounds}\n"
+            f"         CRS:                {self.crs}\n"
+            f"         nodata:             {self.nodata}\n"
+            f"         fill_value_default: {self.fill_value_default}\n"
+            f"         Transform:          {transform_str}\n"
+        )
 
     def read(self, **kwargs) -> np.ndarray:
         """
diff --git a/tests/test_abstract_reader.py b/tests/test_abstract_reader.py
index c1c893e..d0af4ce 100644
--- a/tests/test_abstract_reader.py
+++ b/tests/test_abstract_reader.py
@@ -137,22 +137,27 @@ def test_footprint_native_crs(self):
         # Same coverage as bounds — corners match
         assert pol.bounds == reader.bounds
 
-    @pytest.mark.parametrize("method_name", ["load", "read_from_window"])
-    def test_default_read_methods_raise_not_implemented(self, method_name):
-        """Default ``load`` / ``read_from_window`` raise NotImplementedError on a bare subclass."""
+    def test_default_load_raises_not_implemented(self):
+        """Default async ``load`` raises NotImplementedError on a bare subclass."""
         import asyncio
 
         transform = from_origin(0, 100, 10, 10)
         reader = _FakeAsyncReader(transform=transform, crs="EPSG:32631", shape=(3, 100, 100))
 
-        method = getattr(reader, method_name)
-        if method_name == "load":
-            coro = method()
-        else:
-            coro = method(window=None, boundless=True)
+        with pytest.raises(NotImplementedError):
+            asyncio.run(reader.load())
+
+    def test_default_read_from_window_raises_not_implemented(self):
+        """Default sync ``read_from_window`` raises NotImplementedError on a bare subclass.
+
+        ``read_from_window`` is sync (returns a windowed view), mirroring
+        :meth:`RasterioReader.read_from_window`.
+        """
+        transform = from_origin(0, 100, 10, 10)
+        reader = _FakeAsyncReader(transform=transform, crs="EPSG:32631", shape=(3, 100, 100))
 
         with pytest.raises(NotImplementedError):
-            asyncio.run(coro)
+            reader.read_from_window(window=None, boundless=True)
 
 
 class TestSameExtent:
diff --git a/tests/test_async_geotiff_reader.py b/tests/test_async_geotiff_reader.py
index 0ab0207..7549c5a 100644
--- a/tests/test_async_geotiff_reader.py
+++ b/tests/test_async_geotiff_reader.py
@@ -7,14 +7,15 @@
 
 Covers:
 - Metadata properties match RasterioReader for the same fixture.
-- ``read_from_window`` produces a GeoTensor numerically equivalent to
-  RasterioReader's read of the same window.
-- ``read_from_bounds(target_crs=...)`` raises NotImplementedError (anti-goal
-  documented in the design).
-- Concurrent fan-out via ``asyncio.gather`` completes without errors.
+- ``read_from_window`` returns a sync windowed view; ``await view.load()``
+  produces a GeoTensor numerically equivalent to RasterioReader's read of
+  the same window.
+- Concurrent fan-out via ``asyncio.gather`` (over ``view.load()``) completes
+  without errors.
 - ``async with`` context manager works.
 """
 
+import asyncio
 import os
 import tempfile
 
@@ -57,6 +58,38 @@ def cog_fixture():
     shutil.rmtree(tmpdir, ignore_errors=True)
 
 
+@pytest.fixture(scope="module")
+def cog_with_nodata_and_overviews():
+    """A 256x256 tiled COG with explicit nodata=-9999 and a 2x/4x overview ladder.
+
+    Used to exercise paths that the default ``cog_fixture`` doesn't:
+    the ``nodata is not None`` branch of ``fill_value_default``,
+    overview reads, and ``block_windows`` over multiple tile rows.
+    """
+    from rasterio.enums import Resampling
+    tmpdir = tempfile.mkdtemp()
+    fname = "withnodata.tif"
+    path = os.path.join(tmpdir, fname)
+
+    np.random.seed(1)
+    data = np.random.randint(-1000, 5000, size=(3, 256, 256), dtype=np.int16)
+    with rasterio.open(
+        path, "w",
+        driver="GTiff", height=256, width=256, count=3, dtype=data.dtype,
+        crs="EPSG:32631", transform=from_origin(500000.0, 4600000.0, 10.0, 10.0),
+        tiled=True, blockxsize=64, blockysize=64, compress="deflate", nodata=-9999,
+    ) as dst:
+        dst.write(data)
+    with rasterio.open(path, "r+") as ds:
+        ds.build_overviews([2, 4], Resampling.average)
+
+    store = obstore.store.LocalStore(prefix=tmpdir)
+    yield {"store": store, "fname": fname, "abs_path": path, "tmpdir": tmpdir}
+
+    import shutil
+    shutil.rmtree(tmpdir, ignore_errors=True)
+
+
 class TestAsyncGeoTIFFReader:
     """Smoke + parity tests for AsyncGeoTIFFReader."""
 
@@ -83,14 +116,21 @@ def test_metadata_before_open_raises(self, cog_fixture):
 
     @pytest.mark.asyncio
     async def test_read_parity_with_rasterio_reader(self, cog_fixture):
-        """A windowed async read returns the same bytes as RasterioReader on the same window."""
+        """Windowed view + load returns the same bytes as RasterioReader on the same window.
+
+        Both readers follow the lazy-view + load pattern: ``read_from_window``
+        is sync (returns a windowed view), ``load`` materialises.
+        """
         async_reader = await AsyncGeoTIFFReader.open(
             cog_fixture["fname"], store=cog_fixture["store"],
         )
         rio_reader = RasterioReader(cog_fixture["abs_path"])
 
         win = rasterio.windows.Window(col_off=8, row_off=4, width=32, height=24)
-        async_gt = await async_reader.read_from_window(win)
+        async_view = async_reader.read_from_window(win)
+        # The view itself reports the windowed shape — no I/O yet.
+        assert async_view.shape == (3, 24, 32)
+        async_gt = await async_view.load()
         rio_gt = rio_reader.read_from_window(win).load()
 
         assert async_gt.values.shape == (3, 24, 32)
@@ -108,40 +148,23 @@ async def test_load_returns_full_extent(self, cog_fixture):
         assert gt.values.shape == (3, 64, 64)
         assert np.array_equal(gt.values, expected)
 
-    @pytest.mark.asyncio
-    async def test_read_bounds_warp_not_implemented(self, cog_fixture):
-        """``read_from_bounds(target_crs=...)`` raises ``NotImplementedError``.
-
-        async-geotiff explicitly disclaims warp/resample; this reader follows
-        suit and surfaces the limitation up front rather than silently
-        falling back.
-        """
-        reader = await AsyncGeoTIFFReader.open(cog_fixture["fname"], store=cog_fixture["store"])
-
-        bounds = reader.bounds
-        with pytest.raises(NotImplementedError, match="warp or resample"):
-            await reader.read_from_bounds(bounds, target_crs="EPSG:4326")
-        with pytest.raises(NotImplementedError, match="warp or resample"):
-            await reader.read_from_bounds(bounds, target_resolution=(20.0, 20.0))
-
     @pytest.mark.asyncio
     async def test_concurrent_fan_out(self, cog_fixture):
-        """``asyncio.gather`` across many windows from one reader completes successfully.
+        """``asyncio.gather`` across many windowed-view loads completes successfully.
 
-        Doesn't claim a speedup against this trivial local fixture — the
-        point is to prove the reader survives concurrent ``await`` calls,
-        which is the actual use case (tile servers fanning out 100s of
-        reads).
+        The actual async I/O is in ``.load()``; ``read_from_window`` is
+        sync window math. Fan-out pattern: build the views (sync),
+        gather their loads (async).
         """
-        import asyncio
-
         reader = await AsyncGeoTIFFReader.open(cog_fixture["fname"], store=cog_fixture["store"])
 
         windows = [
             rasterio.windows.Window(col_off=c, row_off=r, width=16, height=16)
             for r in range(0, 64, 16) for c in range(0, 64, 16)
         ]
-        results = await asyncio.gather(*[reader.read_from_window(w) for w in windows])
+        results = await asyncio.gather(
+            *[reader.read_from_window(w).load() for w in windows]
+        )
 
         assert len(results) == 16
         for gt in results:
@@ -160,9 +183,260 @@ async def test_async_context_manager(self, cog_fixture):
 
     @pytest.mark.asyncio
     async def test_repr(self, cog_fixture):
-        """``__repr__`` reflects open status."""
+        """``__repr__`` is terse when unopened and shows metadata when opened."""
         reader = AsyncGeoTIFFReader(cog_fixture["fname"], store=cog_fixture["store"])
         assert "unopened" in repr(reader)
 
         await reader._open_geotiff()
-        assert "opened" in repr(reader)
+        r = repr(reader)
+        # Rich opened repr shows the same fields as RasterioReader.
+        for field in ("path_or_url", "Shape", "Resolution", "Bounds", "CRS", "Transform"):
+            assert field in r
+
+    @pytest.mark.asyncio
+    async def test_read_from_window_boundless(self, cog_fixture):
+        """``boundless=True`` view pads to window shape on load; ``boundless=False`` clips at construction.
+
+        Mirrors RasterioReader.read_from_window's boundless contract: edge
+        windows return the full requested shape under boundless=True (with
+        ``fill_value_default`` in the out-of-bounds region) and a clipped
+        shape under boundless=False.
+        """
+        reader = await AsyncGeoTIFFReader.open(cog_fixture["fname"], store=cog_fixture["store"])
+
+        # 64x64 raster, request a 20x20 window starting at (60, 60) — only
+        # the bottom-right 4x4 is inside the raster.
+        edge_window = rasterio.windows.Window(col_off=60, row_off=60, width=20, height=20)
+
+        boundless_view = reader.read_from_window(edge_window, boundless=True)
+        clipped_view = reader.read_from_window(edge_window, boundless=False)
+
+        # Views report the right shape before any I/O.
+        assert boundless_view.shape == (3, 20, 20)
+        assert clipped_view.shape == (3, 4, 4)
+
+        boundless_gt = await boundless_view.load(boundless=True)
+        clipped_gt = await clipped_view.load(boundless=False)
+
+        assert boundless_gt.values.shape == (3, 20, 20)
+        assert clipped_gt.values.shape == (3, 4, 4)
+        # The clipped tensor should equal the inner 4x4 of the boundless tensor.
+        assert np.array_equal(clipped_gt.values, boundless_gt.values[:, :4, :4])
+
+    @pytest.mark.asyncio
+    async def test_read_from_window_no_intersection_raises(self, cog_fixture):
+        """``read_from_window(boundless=False)`` with a disjoint window raises ``WindowError`` synchronously.
+
+        ``boundless=True`` does NOT raise at view-construction time
+        (matches RasterioReader.set_window), but raises on load.
+        """
+        reader = await AsyncGeoTIFFReader.open(cog_fixture["fname"], store=cog_fixture["store"])
+
+        outside = rasterio.windows.Window(col_off=200, row_off=200, width=10, height=10)
+        with pytest.raises(rasterio.windows.WindowError):
+            reader.read_from_window(outside, boundless=False)
+
+        # boundless=True view construction is permissive; the WindowError
+        # surfaces on load via window_utils.get_slice_pad.
+        view = reader.read_from_window(outside, boundless=True)
+        with pytest.raises(rasterio.windows.WindowError):
+            await view.load(boundless=True)
+
+    # ----------------------------------------------- coverage gap #7
+    def test_read_before_open_raises(self, cog_fixture):
+        """``read_from_window`` and ``load`` raise ``RuntimeError`` before ``open()``.
+
+        Complements ``test_metadata_before_open_raises`` — the same
+        ``_require_open()`` guard should catch read attempts, not just
+        property access.
+        """
+        reader = AsyncGeoTIFFReader(cog_fixture["fname"], store=cog_fixture["store"])
+
+        with pytest.raises(RuntimeError, match="not opened"):
+            reader.read_from_window(rasterio.windows.Window(0, 0, 4, 4))
+
+        with pytest.raises(RuntimeError, match="not opened"):
+            asyncio.run(reader.load())
+
+    # ----------------------------------------------- coverage gap #2
+    @pytest.mark.asyncio
+    async def test_nested_read_from_window_view_of_view(self, cog_fixture):
+        """``reader.read_from_window(w1).read_from_window(w2)`` translates correctly.
+
+        ``w2`` is interpreted relative to the view's window, not the
+        underlying raster — matches :meth:`RasterioReader.set_window`
+        with ``relative=True``. Guards against off-by-one in the
+        relative→absolute translation.
+        """
+        reader = await AsyncGeoTIFFReader.open(cog_fixture["fname"], store=cog_fixture["store"])
+
+        outer = rasterio.windows.Window(col_off=16, row_off=8, width=32, height=24)
+        inner = rasterio.windows.Window(col_off=4, row_off=2, width=8, height=12)
+
+        # Equivalent absolute window (outer offsets + inner offsets).
+        absolute = rasterio.windows.Window(col_off=20, row_off=10, width=8, height=12)
+
+        nested_gt = await reader.read_from_window(outer).read_from_window(inner).load()
+        absolute_gt = await reader.read_from_window(absolute).load()
+
+        assert nested_gt.values.shape == (3, 12, 8)
+        assert nested_gt.transform == absolute_gt.transform
+        assert np.array_equal(nested_gt.values, absolute_gt.values)
+
+    # ----------------------------------------------- coverage gap #4
+    @pytest.mark.asyncio
+    async def test_fill_value_default_uses_explicit_nodata(
+        self, cog_with_nodata_and_overviews,
+    ):
+        """When the COG has ``nodata=N``, ``fill_value_default`` returns ``N``.
+
+        The default fixture has no nodata tag, so this branch is
+        otherwise untested. Verifies edge-window padding under
+        ``boundless=True`` uses the explicit nodata value (-9999).
+        """
+        reader = await AsyncGeoTIFFReader.open(
+            cog_with_nodata_and_overviews["fname"],
+            store=cog_with_nodata_and_overviews["store"],
+        )
+        assert reader.fill_value_default == -9999
+
+        # 256x256 raster — request a 16x16 window straddling the right edge.
+        edge_window = rasterio.windows.Window(col_off=250, row_off=8, width=16, height=16)
+        gt = await reader.read_from_window(edge_window).load(boundless=True)
+
+        assert gt.values.shape == (3, 16, 16)
+        # The rightmost 10 cols (250..256 is 6 valid, then 10 padded) are -9999.
+        assert (gt.values[:, :, 6:] == -9999).all()
+
+    # ----------------------------------------------- coverage gap #5
+    @pytest.mark.asyncio
+    async def test_bounds_and_footprint_reflect_window_focus(self, cog_fixture):
+        """Focused-view ``bounds`` and ``footprint`` derive from the focus, not the full raster."""
+        reader = await AsyncGeoTIFFReader.open(cog_fixture["fname"], store=cog_fixture["store"])
+
+        view = reader.read_from_window(rasterio.windows.Window(col_off=8, row_off=4, width=32, height=24))
+
+        # Bounds should match the windowed transform/shape, NOT the full raster.
+        assert view.bounds != reader.bounds
+        # At 10m/pixel, origin (500000, 4600000) top-left, y descending:
+        #   window (col=8, row=4, w=32, h=24)
+        #   ⇒ top-left geo: (500000 + 80, 4600000 - 40) = (500080, 4599960)
+        #   ⇒ bottom-right:  (500080 + 320, 4599960 - 240) = (500400, 4599720)
+        assert view.bounds == (500080.0, 4599720.0, 500400.0, 4599960.0)
+
+        pol = view.footprint()
+        assert pol.bounds == view.bounds
+
+    # ----------------------------------------------- overviews / reader_overview (gap #1)
+    @pytest.mark.asyncio
+    async def test_overviews_match_rasterio_reader(self, cog_with_nodata_and_overviews):
+        """``overviews()`` returns the same decimation factors as RasterioReader."""
+        reader = await AsyncGeoTIFFReader.open(
+            cog_with_nodata_and_overviews["fname"],
+            store=cog_with_nodata_and_overviews["store"],
+        )
+        rio = RasterioReader(cog_with_nodata_and_overviews["abs_path"])
+
+        assert reader.overviews() == rio.overviews()
+        # The fixture built [2, 4]; assert literal too as a sanity check.
+        assert reader.overviews() == [2, 4]
+
+    @pytest.mark.asyncio
+    async def test_reader_overview_returns_correctly_sized_reader(
+        self, cog_with_nodata_and_overviews,
+    ):
+        """``reader_overview(level)`` returns a reader pinned to that overview's shape."""
+        reader = await AsyncGeoTIFFReader.open(
+            cog_with_nodata_and_overviews["fname"],
+            store=cog_with_nodata_and_overviews["store"],
+        )
+
+        # Index 0 = first overview = half resolution.
+        ov0 = reader.reader_overview(0)
+        assert ov0.shape == (3, 128, 128)
+        gt0 = await ov0.load()
+        assert gt0.values.shape == (3, 128, 128)
+
+        # Negative indexing: -1 = coarsest overview.
+        ovn1 = reader.reader_overview(-1)
+        assert ovn1.shape == (3, 64, 64)
+
+    @pytest.mark.asyncio
+    async def test_reader_overview_warns_when_window_focus_set(
+        self, cog_with_nodata_and_overviews,
+    ):
+        """``reader_overview`` warns and resets window_focus (parent's TODO behavior)."""
+        import warnings
+        reader = await AsyncGeoTIFFReader.open(
+            cog_with_nodata_and_overviews["fname"],
+            store=cog_with_nodata_and_overviews["store"],
+        )
+        focused = reader.read_from_window(rasterio.windows.Window(0, 0, 64, 64))
+
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            ov = focused.reader_overview(0)
+            assert any("window_focus" in str(rec.message) for rec in w)
+        # The overview reader is at full extent (focus reset).
+        assert ov.shape == (3, 128, 128)
+
+    # ----------------------------------------------- block_windows
+    @pytest.mark.asyncio
+    async def test_block_windows_match_rasterio_reader(self, cog_with_nodata_and_overviews):
+        """``block_windows()`` returns the same (index, window) sequence as RasterioReader."""
+        reader = await AsyncGeoTIFFReader.open(
+            cog_with_nodata_and_overviews["fname"],
+            store=cog_with_nodata_and_overviews["store"],
+        )
+        rio = RasterioReader(cog_with_nodata_and_overviews["abs_path"])
+
+        async_blocks = reader.block_windows()
+        rio_blocks = rio.block_windows()
+
+        assert len(async_blocks) == len(rio_blocks)
+        for (a_idx, a_win), (r_idx, r_win) in zip(async_blocks, rio_blocks):
+            assert a_idx == r_idx
+            assert (a_win.col_off, a_win.row_off, a_win.width, a_win.height) == (
+                r_win.col_off, r_win.row_off, r_win.width, r_win.height,
+            )
+
+    @pytest.mark.asyncio
+    async def test_block_windows_clipped_to_window_focus(self, cog_with_nodata_and_overviews):
+        """When window_focus is set, ``block_windows`` returns only intersecting blocks, clipped."""
+        reader = await AsyncGeoTIFFReader.open(
+            cog_with_nodata_and_overviews["fname"],
+            store=cog_with_nodata_and_overviews["store"],
+        )
+        # Focus on a region covering the upper-left 2×2 tiles (each tile is 64×64).
+        focus = rasterio.windows.Window(col_off=32, row_off=32, width=80, height=80)
+        view = reader.read_from_window(focus)
+
+        blocks = view.block_windows()
+        # Without focus there are 16 blocks; the focus intersects 4 in the upper-left.
+        assert len(blocks) == 4
+        # All returned blocks live inside the focus extent.
+        for _, w in blocks:
+            assert w.col_off >= focus.col_off
+            assert w.row_off >= focus.row_off
+            assert w.col_off + w.width <= focus.col_off + focus.width
+            assert w.row_off + w.height <= focus.row_off + focus.height
+
+    @pytest.mark.asyncio
+    async def test_block_aligned_fan_out(self, cog_with_nodata_and_overviews):
+        """Reading via ``block_windows`` + ``asyncio.gather`` produces full coverage with no overlap.
+
+        This is the canonical tile-server pattern the reader was built
+        for — fanning out reads tile-aligned with the COG's internal grid.
+        """
+        reader = await AsyncGeoTIFFReader.open(
+            cog_with_nodata_and_overviews["fname"],
+            store=cog_with_nodata_and_overviews["store"],
+        )
+
+        blocks = reader.block_windows()
+        chips = await asyncio.gather(
+            *[reader.read_from_window(w).load() for _, w in blocks]
+        )
+        assert len(chips) == 16  # 4×4 blocks of 64×64 in a 256×256 raster
+        total_pixels = sum(c.values.shape[1] * c.values.shape[2] for c in chips)
+        assert total_pixels == 256 * 256
diff --git a/tests/test_read_dataarray.py b/tests/test_read_dataarray.py
index b1fce6c..9c749e2 100644
--- a/tests/test_read_dataarray.py
+++ b/tests/test_read_dataarray.py
@@ -11,15 +11,20 @@
 The test file has: 15 bands, height=200, width=250, CRS=EPSG:32738, resolution=10.0m
 """
 
+import asyncio
 import itertools
 import math
+import os
 
 import numpy as np
 import pytest
 import rasterio
+import rasterio.warp
 import rasterio.windows
+from shapely.geometry import box
 
 from georeader import dataarray, rasterio_reader, read
+from georeader.geotensor import GeoTensor
 
 # Define windows for testing - based on the test image dimensions (height=200, width=250)
 # Normal window within bounds
@@ -97,25 +102,91 @@ def get_test_windows(test_raster_path):
 TEST_COMBINATIONS = list(itertools.product(TEST_WINDOWS, TRIGGER_LOAD_OPTIONS))
 
 
-@pytest.mark.parametrize("window,trigger_load", TEST_COMBINATIONS)
-def test_read_window(test_raster_path, window, trigger_load):
+# =============================================================================
+# Parametrized reader fixture — runs each `read.*` test against both
+# RasterioReader (sync) and AsyncGeoTIFFReader (async). Mirrors the
+# reviewer's request to avoid copy-paste and exercise the read module's
+# polymorphism over the two reader types.
+# =============================================================================
+
+def _materialize_sync(view_or_tensor):
+    """Convert a lazy reader view (or pre-built GeoTensor) into a GeoTensor."""
+    if view_or_tensor is None or isinstance(view_or_tensor, GeoTensor):
+        return view_or_tensor
+    return view_or_tensor.load()
+
+
+def _materialize_async(view_or_tensor):
+    """Async sibling of _materialize_sync — drives ``view.load()`` via asyncio.run."""
+    if view_or_tensor is None or isinstance(view_or_tensor, GeoTensor):
+        return view_or_tensor
+    return asyncio.run(view_or_tensor.load())
+
+
+@pytest.fixture(params=["sync", "async"])
+def reader_and_materialize(request, test_raster_path):
+    """Yield ``(reader, materialize)`` for each reader backend.
+
+    The ``materialize`` helper turns whatever ``read.*`` returns
+    (lazy reader view, pre-built GeoTensor, or None for the
+    no-intersection-boundless-False branch) into a GeoTensor that the
+    test can assert against — handling sync ``.load()`` or async
+    ``await view.load()`` transparently.
+    """
+    if request.param == "sync":
+        reader = rasterio_reader.RasterioReader(test_raster_path)
+        yield reader, _materialize_sync
+        return
+
+    # async path — skip cleanly if the optional extra isn't installed.
+    pytest.importorskip("async_geotiff")
+    obstore = pytest.importorskip("obstore")
+    from georeader.async_geotiff_reader import AsyncGeoTIFFReader
+
+    store = obstore.store.LocalStore(prefix=os.path.dirname(test_raster_path))
+    fname = os.path.basename(test_raster_path)
+    reader = asyncio.run(AsyncGeoTIFFReader.open(fname, store=store))
+    yield reader, _materialize_async
+
+
+def _as_geotensor_for_reproject(reader, materialize):
+    """Coerce a reader into a GeoTensor so ``read.read_reproject`` can consume it.
+
+    ``read.read_reproject`` materialises source data internally via a
+    sync ``trigger_load=True`` ([read.py:1547](../georeader/read.py#L1547)
+    and [read.py:1605-1608](../georeader/read.py#L1605-L1608)) — fine
+    for sync readers, returns a coroutine for async. The
+    ``isinstance(data_in, GeoTensor)`` short-circuit at
+    [read.py:1605](../georeader/read.py#L1605) is the seam: if the
+    input is already in memory, the sync-load path is skipped.
+
+    So the canonical async pattern is: pre-load (1 ``await``) then
+    pass the GeoTensor. No ``aread_reproject`` needed — same function
+    works for both readers.
+    """
+    return materialize(reader.read_from_window(rasterio.windows.Window(
+        col_off=0, row_off=0, width=reader.shape[-1], height=reader.shape[-2],
+    )))
+
+
+@pytest.mark.parametrize("window", TEST_WINDOWS)
+def test_read_window(reader_and_materialize, test_raster_path, window):
     """
     Test reading data from a window using read.read_from_window.
 
-    This test verifies that:
-    1. The read_from_window function correctly slices data from a raster
-    2. The output shape matches the window dimensions
-    3. The bounds and transform of the output match expected values
-    4. The actual data values match what rasterio would read directly
+    Runs against both RasterioReader (sync) and AsyncGeoTIFFReader
+    (async) via the ``reader_and_materialize`` fixture.
 
-    Args:
-        test_raster_path: Path to the test raster file (fixture)
-        window: Window to read from
-        trigger_load: Whether to trigger loading data into memory
+    Verifies:
+    1. read_from_window correctly slices data from a raster
+    2. Output shape matches the window dimensions
+    3. Bounds and transform of the output match expected values
+    4. Actual data values match what rasterio would read directly
     """
-    rst = rasterio_reader.RasterioReader(test_raster_path)
+    reader, materialize = reader_and_materialize
 
-    chip_out = read.read_from_window(rst, window, trigger_load=trigger_load)
+    result = read.read_from_window(reader, window)
+    chip_out = materialize(result)
 
     # Skip fully out-of-bounds windows when not boundless
     if chip_out is None:
@@ -147,22 +218,35 @@ def test_read_window(test_raster_path, window, trigger_load):
 
 
 @pytest.mark.parametrize("window,trigger_load", TEST_COMBINATIONS)
-def test_read_bounds(test_raster_path, window, trigger_load):
+def test_read_window_sync_trigger_load(test_raster_path, window, trigger_load):
+    """Sync-only smoke test for ``trigger_load`` on ``read.read_from_window``.
+
+    The async path has no equivalent (``trigger_load`` would try to call
+    ``view.load()`` synchronously — for an async view that returns a
+    coroutine, not a GeoTensor). Keeping this here so the
+    ``trigger_load`` branch of :func:`read.read_from_window` stays
+    covered for the sync reader.
     """
-    Test reading data from bounds using read.read_from_bounds.
+    rst = rasterio_reader.RasterioReader(test_raster_path)
+
+    chip_out = read.read_from_window(rst, window, trigger_load=trigger_load)
+    if chip_out is None:
+        return
+
+    with rasterio.open(test_raster_path) as src:
+        chip_out_expected = src.read(window=window, boundless=True, fill_value=0)
+
+    assert np.allclose(chip_out_expected, chip_out.values)
 
-    This test verifies that:
-    1. The read_from_bounds function correctly reads data for a given bounding box
-    2. The output shape matches the expected dimensions
-    3. The bounds and transform of the output are correct
-    4. The actual data values match what rasterio would read directly
 
-    Args:
-        test_raster_path: Path to the test raster file (fixture)
-        window: Window to derive bounds from
-        trigger_load: Whether to trigger loading data into memory
+@pytest.mark.parametrize("window", TEST_WINDOWS)
+def test_read_bounds(reader_and_materialize, test_raster_path, window):
     """
-    rst = rasterio_reader.RasterioReader(test_raster_path)
+    Test reading data from bounds using read.read_from_bounds.
+
+    Runs against both reader backends via ``reader_and_materialize``.
+    """
+    reader, materialize = reader_and_materialize
 
     with rasterio.open(test_raster_path) as src:
         chip_out_expected = src.read(window=window, boundless=True, fill_value=0)
@@ -170,13 +254,12 @@ def test_read_bounds(test_raster_path, window, trigger_load):
         bounds_read = rasterio.windows.bounds(window, src.transform)
         crs_bounds = src.crs
 
-    chip_out = read.read_from_bounds(rst, bounds_read, crs_bounds=crs_bounds, trigger_load=trigger_load)
+    result = read.read_from_bounds(reader, bounds_read, crs_bounds=crs_bounds)
+    chip_out = materialize(result)
 
-    # Skip fully out-of-bounds windows when not boundless
     if chip_out is None:
         return
 
-    # Check that the output has the correct shape
     named_shape = dict(zip(chip_out.dims, chip_out.shape))
     assert named_shape["y"] == window.height, (
         f"Different height found: ({named_shape['y']}, {named_shape['x']}) expected ({window.height}, {window.width})"
@@ -184,31 +267,273 @@ def test_read_bounds(test_raster_path, window, trigger_load):
     assert named_shape["x"] == window.width, (
         f"Different width found: ({named_shape['y']}, {named_shape['x']}) expected ({window.height}, {window.width})"
     )
-
-    # Verify bounds and transform
     assert chip_out.bounds == bounds_read, f"Different bounds found: {chip_out.bounds} expected: {bounds_read}"
     assert chip_out.transform == expected_transform, (
         f"Different transform found: {chip_out.transform} expected: {expected_transform}"
     )
+    assert np.allclose(chip_out_expected, chip_out.values), "Content of the array is different"
 
-    # Verify the actual data values match
+
+@pytest.mark.parametrize("window", TEST_WINDOWS)
+def test_read_polygon(reader_and_materialize, test_raster_path, window):
+    """Test reading data from a polygon (box) via read.read_from_polygon.
+
+    Uses the window's geographic bounds to build a rectangular polygon
+    and verifies the returned chip matches a direct rasterio read of
+    the same window.
+    """
+    reader, materialize = reader_and_materialize
+
+    with rasterio.open(test_raster_path) as src:
+        bounds_read = rasterio.windows.bounds(window, src.transform)
+        chip_out_expected = src.read(window=window, boundless=True, fill_value=0)
+        crs_bounds = src.crs
+
+    polygon = box(*bounds_read)
+    result = read.read_from_polygon(reader, polygon, crs_polygon=crs_bounds)
+    chip_out = materialize(result)
+
+    if chip_out is None:
+        return
+
+    named_shape = dict(zip(chip_out.dims, chip_out.shape))
+    assert named_shape["y"] == window.height
+    assert named_shape["x"] == window.width
+    assert chip_out.bounds == bounds_read
+    assert np.allclose(chip_out_expected, chip_out.values), "Content of the array is different"
+
+
+# In-bounds windows only — cross-CRS reprojection of out-of-bounds windows is
+# meaningless (bounds wrap or land in invalid lat/lon) and gives noisy failures
+# that don't tell us anything about the read.* polymorphism we're checking.
+IN_BOUNDS_WINDOWS = [WINDOW_NORMAL, WINDOW_BORDER_1, WINDOW_BORDER_2]
+
+
+@pytest.mark.parametrize("window", IN_BOUNDS_WINDOWS)
+def test_read_bounds_cross_crs(reader_and_materialize, test_raster_path, window):
+    """Coverage gap #9 — read.read_from_bounds with bounds in a different CRS.
+
+    The reviewer's wording "shall work with this reader as input
+    regardless of the crs passed because it reprojects the bounds not
+    the data" is exactly this path. Bounds reprojection happens in
+    :func:`window_utils.window_from_bounds` before any I/O — the
+    reader doesn't see the WGS84 bounds, only the resolved native-CRS
+    window.
+    """
+    reader, materialize = reader_and_materialize
+
+    with rasterio.open(test_raster_path) as src:
+        utm_bounds = rasterio.windows.bounds(window, src.transform)
+        src_crs = src.crs
+        chip_out_expected = src.read(window=window, boundless=True, fill_value=0)
+
+    del chip_out_expected  # bounds CRS round-trip shifts the window — byte parity isn't the point here
+    wgs_bounds = rasterio.warp.transform_bounds(src_crs, "EPSG:4326", *utm_bounds)
+    chip_out = materialize(read.read_from_bounds(reader, wgs_bounds, crs_bounds="EPSG:4326"))
+
+    if chip_out is None:
+        return
+    # CRS round-trip introduces a small bounds wiggle; allow ±2 pixels in shape.
+    named_shape = dict(zip(chip_out.dims, chip_out.shape))
+    assert abs(named_shape["y"] - window.height) <= 2
+    assert abs(named_shape["x"] - window.width) <= 2
+    # The reader's data stays in its native CRS — bounds are reprojected
+    # but data is not (the point of read.read_from_bounds with crs_bounds).
+    assert str(chip_out.crs) == str(src_crs)
+
+
+@pytest.mark.parametrize("window", IN_BOUNDS_WINDOWS)
+def test_read_polygon_cross_crs(reader_and_materialize, test_raster_path, window):
+    """Coverage gap #11 — read.read_from_polygon with polygon in a different CRS.
+
+    Same shape as :func:`test_read_bounds_cross_crs` but via the polygon path.
+    """
+    reader, materialize = reader_and_materialize
+
+    with rasterio.open(test_raster_path) as src:
+        utm_bounds = rasterio.windows.bounds(window, src.transform)
+        src_crs = src.crs
+
+    wgs_bounds = rasterio.warp.transform_bounds(src_crs, "EPSG:4326", *utm_bounds)
+    poly = box(*wgs_bounds)
+    chip_out = materialize(read.read_from_polygon(reader, poly, crs_polygon="EPSG:4326"))
+
+    if chip_out is None:
+        return
+    named_shape = dict(zip(chip_out.dims, chip_out.shape))
+    assert abs(named_shape["y"] - window.height) <= 2
+    assert abs(named_shape["x"] - window.width) <= 2
+    assert str(chip_out.crs) == str(src_crs)
+
+
+@pytest.mark.parametrize("pad", [(4, 4), (16, 16), (0, 8)])
+def test_read_bounds_pad_add(reader_and_materialize, test_raster_path, pad):
+    """Coverage gap #10 — read.read_from_bounds with ``pad_add``.
+
+    ``pad_add`` is documented for CNN inference / receptive field
+    context. Verify the output is larger than the unpadded read by
+    exactly ``2 * pad`` in each axis (pad is added on both sides).
+    """
+    reader, materialize = reader_and_materialize
+
+    with rasterio.open(test_raster_path) as src:
+        bounds_read = rasterio.windows.bounds(WINDOW_NORMAL, src.transform)
+        crs_bounds = src.crs
+
+    unpadded = materialize(read.read_from_bounds(reader, bounds_read, crs_bounds=crs_bounds))
+    padded = materialize(read.read_from_bounds(reader, bounds_read, crs_bounds=crs_bounds, pad_add=pad))
+
+    assert unpadded is not None and padded is not None
+    u_shape = dict(zip(unpadded.dims, unpadded.shape))
+    p_shape = dict(zip(padded.dims, padded.shape))
+    assert p_shape["y"] == u_shape["y"] + 2 * pad[0]
+    assert p_shape["x"] == u_shape["x"] + 2 * pad[1]
+
+
+def test_read_window_return_only_data_sync(test_raster_path):
+    """Coverage gap #8 — ``return_only_data=True`` returns a bare numpy array.
+
+    Sync-only: this branch calls ``data_sel.values`` on the reader's
+    view ([read.py:582-583](../georeader/read.py#L582-L583)). For an
+    async reader's view, ``.values`` would need to materialise via
+    ``await load()`` — which the sync read module can't do. The
+    documented workaround for async users is to call ``await
+    view.load()`` and then ``.values`` on the resulting GeoTensor.
+    """
+    rst = rasterio_reader.RasterioReader(test_raster_path)
+    arr = read.read_from_window(rst, WINDOW_NORMAL, return_only_data=True)
+    assert isinstance(arr, np.ndarray)
+    assert arr.shape[-2:] == (WINDOW_NORMAL.height, WINDOW_NORMAL.width)
+
+
+@pytest.mark.parametrize("window", TEST_WINDOWS)
+def test_read_center_coords(reader_and_materialize, test_raster_path, window):
+    """Test read.read_from_center_coords against both reader backends.
+
+    Computes the geographic center of the window and reads back a chip
+    of the same (height, width); compares to a direct rasterio read.
+    """
+    reader, materialize = reader_and_materialize
+
+    with rasterio.open(test_raster_path) as src:
+        bounds_read = rasterio.windows.bounds(window, src.transform)
+        chip_out_expected = src.read(window=window, boundless=True, fill_value=0)
+        crs_bounds = src.crs
+
+    center = ((bounds_read[0] + bounds_read[2]) / 2.0, (bounds_read[1] + bounds_read[3]) / 2.0)
+    shape = (window.height, window.width)
+
+    result = read.read_from_center_coords(
+        reader, center_coords=center, shape=shape, crs_center_coords=crs_bounds,
+    )
+    chip_out = materialize(result)
+
+    if chip_out is None:
+        return
+
+    named_shape = dict(zip(chip_out.dims, chip_out.shape))
+    assert named_shape["y"] == window.height
+    assert named_shape["x"] == window.width
+    assert np.allclose(chip_out_expected, chip_out.values), "Content of the array is different"
+
+
+def test_read_from_tile(reader_and_materialize, test_raster_path):
+    """Test read.read_from_tile against both reader backends.
+
+    Picks an XYZ tile whose footprint intersects the test raster (the
+    raster is in EPSG:32738 South-East Africa; pick a low-zoom tile
+    covering that area) and verifies that the returned chip has the
+    expected web-mercator shape and CRS.
+    """
+    reader, materialize = reader_and_materialize
+
+    # Compute a Z/X/Y tile covering the raster's geographic center.
+    with rasterio.open(test_raster_path) as src:
+        center_x = (src.bounds.left + src.bounds.right) / 2.0
+        center_y = (src.bounds.bottom + src.bounds.top) / 2.0
+        src_crs = src.crs
+
+    lon, lat = rasterio.warp.transform(src_crs, "EPSG:4326", [center_x], [center_y])
+    lon, lat = lon[0], lat[0]
+
+    z = 12
+    n = 2 ** z
+    xtile = int((lon + 180.0) / 360.0 * n)
+    ytile = int((1.0 - math.log(math.tan(math.radians(lat)) + 1.0 / math.cos(math.radians(lat))) / math.pi) / 2.0 * n)
+
+    result = read.read_from_tile(reader, x=xtile, y=ytile, z=z)
+    chip_out = materialize(result)
+
+    if chip_out is None:
+        return
+
+    # Web-mercator tile reads return EPSG:3857 by default.
+    assert str(chip_out.crs) == "EPSG:3857" or "3857" in str(chip_out.crs)
+    # Tile shape is non-degenerate.
+    named_shape = dict(zip(chip_out.dims, chip_out.shape))
+    assert named_shape["y"] > 0
+    assert named_shape["x"] > 0
+
+
+@pytest.mark.parametrize("window", TEST_WINDOWS)
+def test_read_reproject_like(reader_and_materialize, test_raster_path, window):
+    """Test read.read_reproject_like — reproject reader to match a GeoTensor template.
+
+    Constructs an in-memory GeoTensor whose bounds correspond to the
+    test window in the reader's native CRS. Asks the reader to
+    reproject onto that template and verifies shape, bounds, and (loose)
+    value equality with a direct rasterio read of the same window.
+
+    Async readers are coerced to a GeoTensor first via
+    :func:`_as_geotensor_for_reproject`; ``read.read_reproject_like``
+    then takes the in-memory short-circuit at
+    [read.py:1605](../georeader/read.py#L1605).
+    """
+    reader, materialize = reader_and_materialize
+    reader = _as_geotensor_for_reproject(reader, materialize)
+
+    with rasterio.open(test_raster_path) as src:
+        chip_out_expected = src.read(window=window, boundless=True, fill_value=0)
+        expected_transform = rasterio.windows.transform(window, src.transform)
+        bounds_read = rasterio.windows.bounds(window, src.transform)
+        crs_bounds = src.crs
+
+    template = GeoTensor(
+        np.zeros((1, window.height, window.width), dtype=np.float32),
+        transform=expected_transform,
+        crs=crs_bounds,
+    )
+
+    chip_out = read.read_reproject_like(reader, template)
+
+    if chip_out is None:
+        return
+
+    named_shape = dict(zip(chip_out.dims, chip_out.shape))
+    assert named_shape["y"] == window.height
+    assert named_shape["x"] == window.width
+    assert chip_out.bounds == bounds_read, f"Different bounds: {chip_out.bounds} vs {bounds_read}"
+    # Reprojection at same CRS / resolution is a pixel-aligned copy → exact match.
     assert np.allclose(chip_out_expected, chip_out.values), "Content of the array is different"
 
 
 @pytest.mark.parametrize("window", TEST_WINDOWS)
-def test_read_reproject_same(test_raster_path, window):
+def test_read_reproject_same(reader_and_materialize, test_raster_path, window):
     """
     Test reprojecting data to the same CRS and resolution.
 
-    This test verifies that when reprojecting data to the same CRS with the same
-    resolution, we get back equivalent data. This is essentially a round-trip test
-    for the read_reproject function.
+    Round-trip test for read_reproject — reprojecting to the source's
+    own CRS at the same resolution should return pixel-aligned data.
 
-    Args:
-        test_raster_path: Path to the test raster file (fixture)
-        window: Window to derive bounds from
+    For async readers, pre-load the source into a GeoTensor before
+    calling read_reproject. ``read.read_reproject`` short-circuits the
+    sync materialisation when ``isinstance(data_in, GeoTensor)`` at
+    [read.py:1605](../georeader/read.py#L1605), so no ``aread_reproject``
+    sibling is needed — the existing function handles both readers via
+    this pattern.
     """
-    rst = rasterio_reader.RasterioReader(test_raster_path)
+    reader, materialize = reader_and_materialize
+    reader = _as_geotensor_for_reproject(reader, materialize)
 
     with rasterio.open(test_raster_path) as src:
         chip_out_expected = src.read(window=window, boundless=True, fill_value=0)
@@ -217,7 +542,7 @@ def test_read_reproject_same(test_raster_path, window):
         crs_bounds = src.crs
 
     chip_out = read.read_reproject(
-        rst,
+        reader,
         bounds=bounds_read,
         dst_crs=crs_bounds,
         resolution_dst_crs=(abs(expected_transform.a), abs(expected_transform.e)),
@@ -250,19 +575,18 @@ def test_read_reproject_same(test_raster_path, window):
 
 
 @pytest.mark.parametrize("window", TEST_WINDOWS)
-def test_read_reproject_other_res(test_raster_path, window):
+def test_read_reproject_other_res(reader_and_materialize, test_raster_path, window):
     """
     Test reprojecting data to a different resolution.
 
-    This test verifies that read_reproject correctly handles resolution changes.
-    When changing from 10m to 5m resolution, the output should have 2x the number
-    of pixels in each dimension.
-
-    Args:
-        test_raster_path: Path to the test raster file (fixture)
-        window: Window to derive bounds from
+    Verifies read_reproject correctly handles resolution changes:
+    10m → 5m should yield 2x the pixels in each dimension. Runs
+    against both reader backends via ``reader_and_materialize`` —
+    async readers via the pre-load pattern (see
+    :func:`_as_geotensor_for_reproject`).
     """
-    rst = rasterio_reader.RasterioReader(test_raster_path)
+    reader, materialize = reader_and_materialize
+    reader = _as_geotensor_for_reproject(reader, materialize)
 
     with rasterio.open(test_raster_path) as src:
         expected_transform = rasterio.windows.transform(window, src.transform)
@@ -270,7 +594,7 @@ def test_read_reproject_other_res(test_raster_path, window):
         factor_diff_shape = np.array(src.res) / np.array(RESOLUTION_TEST)
         crs_bounds = src.crs
 
-    chip_out = read.read_reproject(rst, bounds=bounds_read, dst_crs=crs_bounds, resolution_dst_crs=RESOLUTION_TEST)
+    chip_out = read.read_reproject(reader, bounds=bounds_read, dst_crs=crs_bounds, resolution_dst_crs=RESOLUTION_TEST)
 
     # Skip fully out-of-bounds windows
     if chip_out is None:
@@ -303,29 +627,54 @@ def test_read_reproject_other_res(test_raster_path, window):
     )
 
 
-def test_read_after_set_window(test_raster_path):
+@pytest.fixture(params=["sync", "async"])
+def reader_pair_and_materialize(request, test_raster_path):
+    """Yield ``(reader_full, reader_focused, materialize)`` for both backends.
+
+    ``reader_full`` has no pre-set ``window_focus``; ``reader_focused`` is
+    constructed with a ``window_focus=Window(50, 50, 100, 100)``.
+    Used by :func:`test_read_after_set_window`.
     """
-    Test that reading from bounds works correctly with and without a window_focus set.
+    focus = rasterio.windows.Window(col_off=50, row_off=50, width=100, height=100)
+
+    if request.param == "sync":
+        full = rasterio_reader.RasterioReader(test_raster_path)
+        focused = rasterio_reader.RasterioReader(test_raster_path, window_focus=focus)
+        yield full, focused, _materialize_sync
+        return
 
-    This test verifies that the read_from_bounds function produces the same results
-    regardless of whether a window_focus is set on the reader, ensuring consistent
-    behavior when using different reading patterns.
+    pytest.importorskip("async_geotiff")
+    obstore = pytest.importorskip("obstore")
+    from georeader.async_geotiff_reader import AsyncGeoTIFFReader
+
+    store = obstore.store.LocalStore(prefix=os.path.dirname(test_raster_path))
+    fname = os.path.basename(test_raster_path)
+    full = asyncio.run(AsyncGeoTIFFReader.open(fname, store=store))
+    focused = asyncio.run(AsyncGeoTIFFReader.open(fname, store=store))
+    focused.window_focus = focus
+    yield full, focused, _materialize_async
+
+
+def test_read_after_set_window(reader_pair_and_materialize, test_raster_path):
     """
-    # Create a window that is within the image bounds (height=200, width=250)
-    window_focus = rasterio.windows.Window(col_off=50, row_off=50, width=100, height=100)
+    Test that reading from bounds works correctly with and without a window_focus set.
 
-    rst1 = rasterio_reader.RasterioReader(test_raster_path)
-    rst2 = rasterio_reader.RasterioReader(test_raster_path, window_focus=window_focus)
+    Verifies that read_from_bounds produces the same results regardless
+    of whether a ``window_focus`` was set on the reader before the call.
+    Runs against both reader backends to confirm the windowed-view
+    pattern is consistent between :class:`RasterioReader` and
+    :class:`AsyncGeoTIFFReader`.
+    """
+    full_reader, focused_reader, materialize = reader_pair_and_materialize
 
     # Get bounds within the window_focus area using the raster's CRS
     with rasterio.open(test_raster_path) as src:
-        # Compute bounds for a small area within window_focus
         inner_window = rasterio.windows.Window(col_off=75, row_off=75, width=50, height=50)
         bounds_read = rasterio.windows.bounds(inner_window, src.transform)
         crs_bounds = src.crs
 
-    data1 = read.read_from_bounds(rst1, bounds_read, crs_bounds=crs_bounds)
-    data2 = read.read_from_bounds(rst2, bounds_read, crs_bounds=crs_bounds)
+    data1 = materialize(read.read_from_bounds(full_reader, bounds_read, crs_bounds=crs_bounds))
+    data2 = materialize(read.read_from_bounds(focused_reader, bounds_read, crs_bounds=crs_bounds))
 
     assert data1.bounds == data2.bounds, f"Different bounds found: {data1.bounds} expected: {data2.bounds}"
     assert data1.transform == data2.transform, (

From 21c2b7cfd8c8937cd32971f3c16f71ea6f46a9db Mon Sep 17 00:00:00 2001
From: Juan Emmanuel Johnson <jemanjohnson34@gmail.com>
Date: Mon, 18 May 2026 08:30:33 +0200
Subject: [PATCH 7/7] docs(notebooks): address PR review + fix read_from_tile
 intersection bug
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Notebook changes (responding to gonzmg88's review on PR #54):

- docs/advanced/async_geotiff_reader.ipynb — rebuilt from 29 → 39 cells:
  - Added a 60-second async/await primer + "when is async worth it?"
    section for users new to async Python
  - Replaced raw rasterio fixture construction with `save_cog` (with
    `BLOCKSIZE=64` so a 256×256 raster still gets overviews)
  - Documented the view+load pattern explicitly with a quick-reference
    table; cleaned stale references to the removed
    `reader.read_from_bounds(target_crs=...)` method
  - Added a `read.*` compatibility matrix with three categories
    (✅ direct / ⚠️ pre-load required / ❌ not supported) and three
    runnable demos covering the cases
  - Added a `block_windows` tile-aligned fan-out demo (the actual
    recommended pattern for tile servers)
  - Added a bandwidth-conscious tile-reads section showing how to
    compose `read_from_bounds` + `read_to_crs` to fetch only the
    tile-region instead of pre-loading the whole COG
  - Replaced the hand-rolled "print each property" cell with
    `print(reader)` (rich __repr__) + programmatic-access assertions
  - Dropped the misleading "~80 LOC adapter" claim from the diagram
    and the module docstring; described scope honestly

- docs/read_S2_SAFE_from_bucket.ipynb — replaced the JP2-implying
  pseudocode sidebar with an upfront limitation note ("AsyncTiffException:
  unexpected magic bytes" — async-geotiff is TIFF-only, JP2 is not
  supported) plus a real runnable example against the Element 84 L2A
  COG bucket

- notebooks/read_from_tileserver.ipynb — reverted: dropped the 4-cell
  AsyncGeoTIFFReader sidebar that didn't belong (notebook is about
  XYZ tile stitching, an unrelated protocol)

- notebooks/Sentinel-2/read_s2_safe_element84_cloud.ipynb — appended
  the Element 84 async fan-out demo in the right place (alongside the
  existing pystac + S2_SAFE_reader content)

Bug fix uncovered while writing the compatibility-matrix proof:

- georeader/read.py:1832-1835 — `read.read_from_tile` had an inverted
  intersection check (`else: return` was returning None for *intersecting*
  tiles, falling through to the rest of the function only for
  non-intersecting tiles). The existing parametrized test passed by
  accident because of an `if chip_out is None: return` early-out.
  Swapped the control flow to match the docstring's promise; tightened
  the test to assert non-None for a center-of-raster tile so the
  regression can't recur silently. With the fix, `read.read_from_tile`
  joins `read_reproject` / `read_reproject_like` / `read_to_crs` in the
  ⚠️ pre-load column for async readers (the function falls through to
  `read_reproject` when the reader has no native `read_from_tile`
  method).

Suite still: 926 passed, 0 skipped, 0 failed.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
---
 docs/advanced/async_geotiff_reader.ipynb      | 824 +++++++++++++-----
 docs/read_S2_SAFE_from_bucket.ipynb           | 108 ++-
 georeader/async_geotiff_reader.py             |  15 +-
 georeader/read.py                             |   3 +-
 .../read_s2_safe_element84_cloud.ipynb        |  69 ++
 notebooks/read_from_tileserver.ipynb          | 120 ---
 tests/test_read_dataarray.py                  |  18 +-
 7 files changed, 796 insertions(+), 361 deletions(-)

diff --git a/docs/advanced/async_geotiff_reader.ipynb b/docs/advanced/async_geotiff_reader.ipynb
index 53fb43d..b576cab 100644
--- a/docs/advanced/async_geotiff_reader.ipynb
+++ b/docs/advanced/async_geotiff_reader.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
-   "id": "d3f7dadc",
+   "id": "72e49519",
    "metadata": {},
    "source": [
     "# AsyncGeoTIFFReader — async COG reads with `asyncio.gather`\n",
@@ -10,19 +10,92 @@
     "`AsyncGeoTIFFReader` is georeader's async-native COG reader. It satisfies the\n",
     "`AsyncGeoData` protocol, exposes the same metadata surface as `RasterioReader`,\n",
     "and lets you fan out hundreds of reads concurrently from a single process with\n",
-    "`asyncio.gather`. It is a **thin (~80-LOC) adapter** over\n",
+    "`asyncio.gather`. It is a **thin adapter** over\n",
     "[`developmentseed/async-geotiff`](https://github.com/developmentseed/async-geotiff):\n",
     "IFD walk, tile-fetch math, decompression dispatch, and request coalescing all\n",
-    "live upstream — we contribute the carrier translation and protocol conformance.\n",
+    "live upstream — we contribute the carrier translation, the lazy-view pattern,\n",
+    "and protocol conformance with the rest of georeader.\n",
     "\n",
     "**Audience.** Anyone who has used `RasterioReader` and is wondering when to\n",
     "reach for the async sibling — what changes, what stays the same, what the\n",
-    "two-phase laziness model looks like, and how to do the things async-geotiff\n",
-    "deliberately doesn't (warp, resample).\n",
+    "two-phase laziness model looks like, which `read.*` module functions work\n",
+    "out of the box, and how to do the things `async-geotiff` deliberately\n",
+    "doesn't (warp, resample).\n",
     "\n",
-    "This notebook runs against a small local fixture — no credentials, no network.\n",
-    "The patterns translate to S3 / GCS / Azure by swapping `LocalStore` for the\n",
-    "appropriate `obstore.store.*` class (last section shows the pseudocode).\n"
+    "This notebook runs against a small local fixture — no credentials, no\n",
+    "network. The patterns translate to S3 / GCS / Azure by swapping `LocalStore`\n",
+    "for the appropriate `obstore.store.*` class (last section shows the\n",
+    "pseudocode).\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "70a1afc5",
+   "metadata": {},
+   "source": [
+    "## A 60-second async/await primer\n",
+    "\n",
+    "If you've never written async Python before, here is the minimum vocabulary\n",
+    "to follow the rest of this notebook.\n",
+    "\n",
+    "- A function declared with `async def` is a **coroutine**. Calling it does\n",
+    "  **not** run the body — it returns a coroutine object that has to be\n",
+    "  scheduled on an **event loop** to execute.\n",
+    "- The `await` keyword runs a coroutine and gives back its return value.\n",
+    "  You can only `await` inside an `async def` (or at the top level of a\n",
+    "  Jupyter cell, which Jupyter wraps in one for you).\n",
+    "- `asyncio.gather(coro1, coro2, ...)` schedules many coroutines on the\n",
+    "  event loop **at the same time**. While one is parked on I/O, the others\n",
+    "  can make progress. The result is the list of return values, in order.\n",
+    "- `asyncio.run(main())` is how you bootstrap an event loop from a normal\n",
+    "  sync entry point (a script's `if __name__ == \"__main__\":`, a CLI, etc).\n",
+    "  In Jupyter you don't need this — the cell already has a running loop.\n",
+    "\n",
+    "Concurrent vs sequential, by example::\n",
+    "\n",
+    "    # Sequential — each await blocks the loop until the read returns\n",
+    "    gt1 = await reader.read_from_window(w1).load()\n",
+    "    gt2 = await reader.read_from_window(w2).load()\n",
+    "    gt3 = await reader.read_from_window(w3).load()\n",
+    "    # Total wall time ≈ sum of individual latencies.\n",
+    "\n",
+    "    # Concurrent — gather schedules all three, the event loop multiplexes\n",
+    "    gt1, gt2, gt3 = await asyncio.gather(\n",
+    "        reader.read_from_window(w1).load(),\n",
+    "        reader.read_from_window(w2).load(),\n",
+    "        reader.read_from_window(w3).load(),\n",
+    "    )\n",
+    "    # Total wall time ≈ max of individual latencies (when bytes-in-flight\n",
+    "    # is the bottleneck, which is the cloud-read case).\n",
+    "\n",
+    "That's it for this notebook. The\n",
+    "[Python asyncio docs](https://docs.python.org/3/library/asyncio-task.html)\n",
+    "go deeper on tasks, queues, cancellation, and the rest.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2820bffc",
+   "metadata": {},
+   "source": [
+    "## When is async actually worth it?\n",
+    "\n",
+    "Async is **only** a win when your reads are bottlenecked on\n",
+    "**concurrent I/O latency** — typically cloud reads where each\n",
+    "`read_from_window` is a 50–200 ms HTTP round-trip and you have many of\n",
+    "them to issue. Then `asyncio.gather` overlaps the wait times and your\n",
+    "wall-clock cost is close to the slowest single read instead of the sum.\n",
+    "\n",
+    "Async is **not** a win when:\n",
+    "\n",
+    "- Reads are local (memory-mapped or fast SSD). Per-call latency is too\n",
+    "  small for overlap to matter; the event-loop overhead can even dominate.\n",
+    "- You issue one read at a time. No concurrency, no overlap, no win.\n",
+    "- You need per-row CPU-heavy work between reads. Async doesn't parallelise\n",
+    "  CPU — it only overlaps waiting. Use `multiprocessing` for CPU.\n",
+    "\n",
+    "If you're not sure, profile your sync path first. Most of the time\n",
+    "`RasterioReader` is the right answer.\n"
    ]
   },
   {
@@ -94,7 +167,7 @@
     "  </div>\n",
     "  <div style=\"text-align: center; font-size: 1.4em; color: #555; line-height: 1;\">&darr; delegates to</div>\n",
     "  <div style=\"border: 2px solid #f57c00; border-radius: 10px; padding: 14px; background: #fff3e0;\">\n",
-    "    <strong>AsyncGeoTIFFReader</strong> &middot; <em style=\"color:#555;\">this package, ~80 LOC adapter</em><br/>\n",
+    "    <strong>AsyncGeoTIFFReader</strong> &middot; <em style=\"color:#555;\">this package, thin adapter, lazy-view pattern</em><br/>\n",
     "    <small>Carrier translation (RasterArray &rarr; GeoTensor), protocol conformance, overview indexing</small>\n",
     "  </div>\n",
     "  <div style=\"text-align: center; font-size: 1.4em; color: #555; line-height: 1;\">&darr; wraps</div>\n",
@@ -147,25 +220,29 @@
   },
   {
    "cell_type": "markdown",
-   "id": "f9fd78f8",
+   "id": "1b722024",
    "metadata": {},
    "source": [
-    "## Setup — build a small local COG fixture with overviews\n",
+    "## Setup — build a small local COG fixture\n",
     "\n",
-    "We build a 256&times;256 tiled GeoTIFF with a 2&times;/4&times; overview ladder\n",
-    "so we can demonstrate both full-resolution and overview reads."
+    "We use `georeader.save.save_cog` to build a tiled COG with overviews in\n",
+    "two lines. Behind the scenes, `save_cog` writes the GeoTensor, opens it\n",
+    "in update mode, builds an overview ladder sized to the raster, and emits\n",
+    "a COG-driver TIFF. `BLOCKSIZE=64` picks a small tile size so a 256×256\n",
+    "raster gets two overview levels (`[2, 4]`); the default 256-tile size\n",
+    "would give zero overviews on a raster this small.\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 1,
-   "id": "d2957fd0",
+   "id": "313cd767",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:02.804072Z",
-     "iopub.status.busy": "2026-05-14T16:10:02.804000Z",
-     "iopub.status.idle": "2026-05-14T16:10:02.949963Z",
-     "shell.execute_reply": "2026-05-14T16:10:02.949744Z"
+     "iopub.execute_input": "2026-05-18T06:28:06.768649Z",
+     "iopub.status.busy": "2026-05-18T06:28:06.768281Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.050261Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.050027Z"
     }
    },
    "outputs": [
@@ -173,7 +250,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Fixture: /var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/tmp9ka3ou11/demo.tif\n"
+      "Fixture: /var/folders/k9/_v6ywhvj0nq36tpttd3j4mq80000gn/T/tmpcxcmsh62/demo.tif\n"
      ]
     }
    ],
@@ -182,10 +259,11 @@
     "import tempfile\n",
     "\n",
     "import numpy as np\n",
-    "import rasterio\n",
-    "from rasterio.enums import Resampling\n",
     "from rasterio.transform import from_origin\n",
     "\n",
+    "from georeader.geotensor import GeoTensor\n",
+    "from georeader.save import save_cog\n",
+    "\n",
     "tmpdir = tempfile.mkdtemp()\n",
     "fname = \"demo.tif\"\n",
     "fixture_path = os.path.join(tmpdir, fname)\n",
@@ -193,19 +271,15 @@
     "np.random.seed(0)\n",
     "data = np.random.randint(0, 5000, size=(3, 256, 256), dtype=np.int16)\n",
     "\n",
-    "with rasterio.open(\n",
-    "    fixture_path, \"w\",\n",
-    "    driver=\"GTiff\", height=256, width=256, count=3, dtype=data.dtype,\n",
-    "    crs=\"EPSG:32631\", transform=from_origin(500000.0, 4600000.0, 10.0, 10.0),\n",
-    "    tiled=True, blockxsize=64, blockysize=64, compress=\"deflate\",\n",
-    "    nodata=0,\n",
-    ") as dst:\n",
-    "    dst.write(data)\n",
-    "\n",
-    "# Build a 2x / 4x overview ladder so we can read at three resolutions.\n",
-    "with rasterio.open(fixture_path, \"r+\") as ds:\n",
-    "    ds.build_overviews([2, 4], Resampling.average)\n",
-    "    ds.update_tags(ns=\"rio_overview\", resampling=\"average\")\n",
+    "# Build a GeoTensor and save it as a COG via save_cog. It handles tiling,\n",
+    "# overview-ladder sizing, and the COG driver knobs.\n",
+    "gt_fixture = GeoTensor(\n",
+    "    values=data,\n",
+    "    transform=from_origin(500000.0, 4600000.0, 10.0, 10.0),\n",
+    "    crs=\"EPSG:32631\",\n",
+    "    fill_value_default=0,\n",
+    ")\n",
+    "save_cog(gt_fixture, fixture_path, profile={\"nodata\": 0, \"BLOCKSIZE\": 64})\n",
     "\n",
     "print(f\"Fixture: {fixture_path}\")\n"
    ]
@@ -234,10 +308,10 @@
    "id": "c1cefe99",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:02.951119Z",
-     "iopub.status.busy": "2026-05-14T16:10:02.951041Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.050652Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.050362Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.051471Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.051382Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.140624Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.140403Z"
     }
    },
    "outputs": [
@@ -272,10 +346,10 @@
    "id": "9cadf716",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:03.051885Z",
-     "iopub.status.busy": "2026-05-14T16:10:03.051780Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.066819Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.066543Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.141693Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.141630Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.160333Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.160144Z"
     }
    },
    "outputs": [
@@ -283,7 +357,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "After open:  AsyncGeoTIFFReader(path_or_url='demo.tif', overview_level=None, opened)\n"
+      "After open:  \n",
+      "         path_or_url:        demo.tif\n",
+      "         overview_level:     None\n",
+      "         Shape:              (3, 256, 256)\n",
+      "         Resolution:         (10.0, 10.0)\n",
+      "         Bounds:             (500000.0, 4597440.0, 502560.0, 4600000.0)\n",
+      "         CRS:                EPSG:32631\n",
+      "         fill_value_default: 0.0\n",
+      "         Transform:          | 10.00, 0.00, 500000.00|\n",
+      "                             | 0.00,-10.00, 4600000.00|\n",
+      "                             | 0.00, 0.00, 1.00|\n",
+      "\n"
      ]
     }
    ],
@@ -312,10 +397,10 @@
    "id": "88b65eed",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:03.068138Z",
-     "iopub.status.busy": "2026-05-14T16:10:03.068057Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.081854Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.081632Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.161407Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.161343Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.163198Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.163003Z"
     }
    },
    "outputs": [
@@ -323,60 +408,67 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "crs       : EPSG:32631\n",
-      "transform : | 10.00, 0.00, 500000.00|\n",
-      "| 0.00,-10.00, 4600000.00|\n",
-      "| 0.00, 0.00, 1.00|\n",
-      "shape     : (3, 256, 256)    (count, height, width)\n",
-      "dtype     : int16\n",
-      "bounds    : (500000.0, 4597440.0, 502560.0, 4600000.0)\n",
-      "res       : (10.0, 10.0)\n",
-      "dims      : ['band', 'y', 'x']\n",
-      "fill_value_default: 0.0\n"
+      "\n",
+      "         path_or_url:        demo.tif\n",
+      "         overview_level:     None\n",
+      "         Shape:              (3, 256, 256)\n",
+      "         Resolution:         (10.0, 10.0)\n",
+      "         Bounds:             (500000.0, 4597440.0, 502560.0, 4600000.0)\n",
+      "         CRS:                EPSG:32631\n",
+      "         fill_value_default: 0.0\n",
+      "         Transform:          | 10.00, 0.00, 500000.00|\n",
+      "                             | 0.00,-10.00, 4600000.00|\n",
+      "                             | 0.00, 0.00, 1.00|\n",
+      "\n",
+      "\n",
+      "(individual property access also works — assertions above passed)\n"
      ]
     }
    ],
    "source": [
-    "print(f\"crs       : {reader.crs}\")\n",
-    "print(f\"transform : {reader.transform}\")\n",
-    "print(f\"shape     : {reader.shape}    (count, height, width)\")\n",
-    "print(f\"dtype     : {reader.dtype}\")\n",
-    "print(f\"bounds    : {reader.bounds}\")\n",
-    "print(f\"res       : {reader.res}\")\n",
-    "print(f\"dims      : {reader.dims}\")\n",
-    "print(f\"fill_value_default: {reader.fill_value_default}\")\n"
+    "# `__repr__` shows every field in one go (same layout as `RasterioReader`).\n",
+    "print(reader)\n",
+    "\n",
+    "# All fields are also accessible programmatically — useful when you need\n",
+    "# to pass them to other code rather than just look at them.\n",
+    "assert reader.shape == (3, 256, 256)\n",
+    "assert reader.dtype == np.int16\n",
+    "assert str(reader.crs) == \"EPSG:32631\"\n",
+    "assert reader.dims == [\"band\", \"y\", \"x\"]\n",
+    "assert reader.fill_value_default == 0\n",
+    "print(\"\\n(individual property access also works — assertions above passed)\")\n"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "d8bf8e5e",
+   "id": "7bdc8630",
    "metadata": {},
    "source": [
-    "## Reading data\n",
+    "## Reading data — the view + load pattern\n",
     "\n",
-    "Three async read methods, each returning a `GeoTensor` (numpy-subclass\n",
-    "carrier with `.values`, `.transform`, `.crs`, ...):\n",
+    "`AsyncGeoTIFFReader` mirrors `RasterioReader`'s laziness pattern:\n",
     "\n",
-    "| Method | What it reads |\n",
-    "|---|---|\n",
-    "| `await reader.load()` | The whole raster at the current `overview_level`. |\n",
-    "| `await reader.read_from_window(window)` | A `rasterio.windows.Window` region. |\n",
-    "| `await reader.read_from_bounds(bounds)` | A geographic-bounds region, *native CRS only*. |\n",
+    "- **`reader.read_from_window(window)`** is **sync** — it returns a new\n",
+    "  `AsyncGeoTIFFReader` with a `window_focus` set, no I/O. You can chain it,\n",
+    "  inspect `.shape` / `.bounds` / `.transform`, and decide later whether to\n",
+    "  materialise.\n",
+    "- **`await view.load()`** is **async** — this is where the bytes actually\n",
+    "  travel. Returns a `GeoTensor` with `.values`, `.transform`, `.crs`, etc.\n",
     "\n",
-    "The result is numerically identical to `RasterioReader.read_from_window` on\n",
-    "the same window — let's verify:"
+    "This split is what makes the `read.*` module functions work polymorphically\n",
+    "with both readers (more on that below).\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 5,
-   "id": "ffb92183",
+   "id": "de5385cd",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:03.083000Z",
-     "iopub.status.busy": "2026-05-14T16:10:03.082924Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.118031Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.117808Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.164168Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.164106Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.174660Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.174464Z"
     }
    },
    "outputs": [
@@ -384,6 +476,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "Async view (no I/O yet): shape=(3, 48, 64), type=AsyncGeoTIFFReader\n",
       "async_gt.values.shape: (3, 48, 64)\n",
       "sync_gt.values.shape:  (3, 48, 64)\n",
       "Numerically identical: True\n"
@@ -396,8 +489,14 @@
     "\n",
     "win = rasterio.windows.Window(col_off=32, row_off=16, width=64, height=48)\n",
     "\n",
-    "async_gt = await reader.read_from_window(win)\n",
-    "sync_gt = RasterioReader(fixture_path).read_from_window(win).load()\n",
+    "# AsyncGeoTIFFReader: sync view → async load\n",
+    "async_view = reader.read_from_window(win)            # sync, no I/O\n",
+    "print(f\"Async view (no I/O yet): shape={async_view.shape}, type={type(async_view).__name__}\")\n",
+    "async_gt = await async_view.load()                    # async fetch\n",
+    "\n",
+    "# RasterioReader has the same shape: sync view → sync load\n",
+    "sync_view = RasterioReader(fixture_path).read_from_window(win)\n",
+    "sync_gt = sync_view.load()\n",
     "\n",
     "print(f\"async_gt.values.shape: {async_gt.values.shape}\")\n",
     "print(f\"sync_gt.values.shape:  {sync_gt.values.shape}\")\n",
@@ -406,7 +505,23 @@
   },
   {
    "cell_type": "markdown",
-   "id": "15524724",
+   "id": "c85be5b7",
+   "metadata": {},
+   "source": [
+    "### Quick reference\n",
+    "\n",
+    "| What you write | What returns | Sync or async? | When the bytes travel |\n",
+    "|---|---|---|---|\n",
+    "| `reader` | `AsyncGeoTIFFReader` | sync | After `await open()`, only the header |\n",
+    "| `reader.read_from_window(w)` | `AsyncGeoTIFFReader` (windowed view) | sync | Never — just metadata math |\n",
+    "| `await view.load()` | `GeoTensor` | async | Here |\n",
+    "| `await reader.load()` | `GeoTensor` (whole raster) | async | Here |\n",
+    "| `view.shape` / `view.bounds` / `view.transform` | tuple / Affine | sync | Never |\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "80c905f7",
    "metadata": {},
    "source": [
     "## Overviews — reading at lower resolutions\n",
@@ -415,30 +530,27 @@
     "is a smaller copy of the full raster, useful for quick previews, tile-server\n",
     "rendering at low zoom, or saving bandwidth when you don't need full detail.\n",
     "\n",
-    "`AsyncGeoTIFFReader` exposes overviews via the `overview_level` constructor\n",
-    "kwarg:\n",
+    "Two helpers expose the overview chain:\n",
     "\n",
-    "- `overview_level=None` (default) &mdash; read from the **primary IFD**\n",
-    "  (full resolution).\n",
-    "- `overview_level=i` &mdash; read from the **i-th overview** (0-based). For\n",
-    "  a `[2, 4]` ladder, `overview_level=0` is the 2&times;-decimated layer and\n",
-    "  `overview_level=1` is the 4&times;-decimated one.\n",
+    "- **`reader.overviews()`** — returns the decimation factors, e.g. `[2, 4, 8]`.\n",
+    "  Same convention as `RasterioReader.overviews()`.\n",
+    "- **`reader.reader_overview(level)`** — returns a new reader pinned to the\n",
+    "  i-th overview (0-based). Negative indexing supported (`-1` is the\n",
+    "  coarsest overview, *not* full res — matches the parent's convention).\n",
     "\n",
-    "Properties (`shape`, `transform`, `res`, ...) reflect the active level.\n",
-    "Reads happen against the corresponding pixel grid &mdash; you don't pay for\n",
-    "the bytes of higher-resolution levels."
+    "You can also pass `overview_level=` directly to `AsyncGeoTIFFReader.open(...)`.\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 6,
-   "id": "8042f612",
+   "id": "0428b8e0",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:03.119207Z",
-     "iopub.status.busy": "2026-05-14T16:10:03.119123Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.123375Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.123163Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.175764Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.175696Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.178433Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.178261Z"
     }
    },
    "outputs": [
@@ -446,7 +558,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "This COG has 2 overview(s)\n",
+      "Overview decimation factors: [2, 4]\n",
       "\n",
       "Full resolution  : shape=(3, 256, 256), res=(10.0, 10.0)\n",
       "Overview 0 (2x)  : shape=(3, 128, 128), res=(20.0, 20.0)\n",
@@ -455,11 +567,10 @@
     }
    ],
    "source": [
-    "# Inspect what overviews this COG has\n",
-    "n_overviews = len(reader._geotiff.overviews)\n",
-    "print(f\"This COG has {n_overviews} overview(s)\")\n",
+    "# Inspect overviews via the public API (no reaching into _geotiff internals).\n",
+    "print(f\"Overview decimation factors: {reader.overviews()}\")\n",
     "\n",
-    "# Open readers at three resolutions: full-res, 2x-decimated, 4x-decimated\n",
+    "# Three readers at three resolutions.\n",
     "reader_full = await AsyncGeoTIFFReader.open(fname, store=store)               # primary IFD\n",
     "reader_ovr0 = await AsyncGeoTIFFReader.open(fname, store=store, overview_level=0)\n",
     "reader_ovr1 = await AsyncGeoTIFFReader.open(fname, store=store, overview_level=1)\n",
@@ -476,10 +587,10 @@
    "id": "652c7e8e",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:03.124321Z",
-     "iopub.status.busy": "2026-05-14T16:10:03.124265Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.128916Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.128717Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.179359Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.179296Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.183957Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.183758Z"
     }
    },
    "outputs": [
@@ -506,32 +617,33 @@
   },
   {
    "cell_type": "markdown",
-   "id": "93bf2772",
+   "id": "102e9454",
    "metadata": {},
    "source": [
     "## Concurrent fan-out — the killer feature\n",
     "\n",
     "The point of going async is to fan out many reads concurrently from one\n",
-    "process. `asyncio.gather` does it in one line.\n",
+    "process. Build the views synchronously (instant), then `asyncio.gather` the\n",
+    "loads.\n",
     "\n",
     "**Honest disclaimer about local fixtures:** speedups from async only show up\n",
-    "against meaningful per-read latency &mdash; typically *cloud* reads. Against\n",
-    "a local file, the overhead can even dominate. Don't draw timing conclusions\n",
+    "against meaningful per-read latency — typically *cloud* reads. Against a\n",
+    "local file, the overhead can even dominate. Don't draw timing conclusions\n",
     "from this cell; it proves the fan-out *works*, which is the actual question.\n",
-    "Real wins arrive when each `read_from_window` is a 50&ndash;200 ms network\n",
+    "Real wins arrive when each `read_from_window().load()` is a 50–200 ms network\n",
     "round-trip and you have 100+ of them to issue.\n"
    ]
   },
   {
    "cell_type": "code",
    "execution_count": 8,
-   "id": "8d7bbf09",
+   "id": "60e94334",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:03.130080Z",
-     "iopub.status.busy": "2026-05-14T16:10:03.130009Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.135912Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.135636Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.184888Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.184829Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.189417Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.189229Z"
     }
    },
    "outputs": [
@@ -539,7 +651,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Issued 16 concurrent reads against one reader\n",
+      "Issued 16 concurrent loads against one reader\n",
       "All shapes correct: True\n"
      ]
     }
@@ -553,12 +665,68 @@
     "    for r in range(0, 256, 64) for c in range(0, 256, 64)\n",
     "]\n",
     "\n",
-    "results = await asyncio.gather(*[reader.read_from_window(w) for w in windows])\n",
+    "# Build the views synchronously (instant), gather the loads concurrently.\n",
+    "results = await asyncio.gather(\n",
+    "    *[reader.read_from_window(w).load() for w in windows]\n",
+    ")\n",
     "\n",
-    "print(f\"Issued {len(windows)} concurrent reads against one reader\")\n",
+    "print(f\"Issued {len(windows)} concurrent loads against one reader\")\n",
     "print(f\"All shapes correct: {all(r.values.shape == (3, 64, 64) for r in results)}\")\n"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "27d6846a",
+   "metadata": {},
+   "source": [
+    "## Tile-aligned fan-out with `block_windows()`\n",
+    "\n",
+    "The COG's internal tile grid is the natural fan-out unit. Reading\n",
+    "non-aligned windows forces `async-geotiff` to fetch the tiles that *cover*\n",
+    "your window and crop afterward — wasting bytes over the wire. Reading\n",
+    "tile-aligned windows fetches exactly the tiles you need, nothing more.\n",
+    "\n",
+    "`reader.block_windows()` returns the internal tile grid as\n",
+    "`[((row_idx, col_idx), Window), ...]`. Same signature as\n",
+    "`RasterioReader.block_windows()`.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "4b675563",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-18T06:28:07.190450Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.190381Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.195216Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.195023Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "COG has 16 tiles of 64x64\n",
+      "Read 16 tile-aligned chips covering the full raster\n",
+      "Total pixels: 65536\n"
+     ]
+    }
+   ],
+   "source": [
+    "# The COG's native tile grid — fan out aligned with this for best efficiency.\n",
+    "blocks = reader.block_windows()\n",
+    "print(f\"COG has {len(blocks)} tiles of {blocks[0][1].width}x{blocks[0][1].height}\")\n",
+    "\n",
+    "# Tile-aligned fan-out\n",
+    "tile_chips = await asyncio.gather(\n",
+    "    *[reader.read_from_window(w).load() for _, w in blocks]\n",
+    ")\n",
+    "print(f\"Read {len(tile_chips)} tile-aligned chips covering the full raster\")\n",
+    "print(f\"Total pixels: {sum(c.values.shape[1] * c.values.shape[2] for c in tile_chips)}\")\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "fc7d42ca",
@@ -573,14 +741,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "id": "925a8590",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:03.137031Z",
-     "iopub.status.busy": "2026-05-14T16:10:03.136964Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.140968Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.140732Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.196226Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.196161Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.199460Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.199279Z"
     }
    },
    "outputs": [
@@ -602,27 +770,62 @@
   },
   {
    "cell_type": "markdown",
-   "id": "9f3d5ab7",
+   "id": "f0bbaeec",
    "metadata": {},
    "source": [
-    "## What this reader does NOT do\n",
+    "## Using the `read` module with this reader\n",
     "\n",
-    "`async-geotiff` explicitly disclaims warp / resample / overview\n",
-    "auto-selection. We follow the same boundary &mdash; calling\n",
-    "`read_from_bounds(target_crs=...)` or `read_from_bounds(target_resolution=...)`\n",
-    "raises `NotImplementedError` with a clear error message:"
+    "Most user code goes through `georeader.read.*` rather than calling reader\n",
+    "methods directly. Because `AsyncGeoTIFFReader.read_from_window` is **sync**\n",
+    "and returns a windowed view (just like `RasterioReader.read_from_window`),\n",
+    "the entire `read.*` module composes cleanly with the async reader — you\n",
+    "just `await` the resulting view's `.load()`.\n",
+    "\n",
+    "### Compatibility matrix\n",
+    "\n",
+    "| `read.*` function | Async-compatible? | How to call |\n",
+    "|---|---|---|\n",
+    "| `read.read_from_window(reader, w)` | ✅ Yes | `await read.read_from_window(reader, w).load()` |\n",
+    "| `read.read_from_bounds(reader, bounds, crs_bounds=...)` | ✅ Yes | `await read.read_from_bounds(reader, bounds).load()` |\n",
+    "| `read.read_from_polygon(reader, poly, crs_polygon=...)` | ✅ Yes | `await read.read_from_polygon(reader, poly).load()` |\n",
+    "| `read.read_from_center_coords(reader, center, shape, ...)` | ✅ Yes | `await read.read_from_center_coords(...).load()` |\n",
+    "| `read.read_from_tile(reader, x, y, z)` | ⚠️ Pre-load required | `gt = await reader.load(); read.read_from_tile(gt, x, y, z)` |\n",
+    "| `read.read_reproject(reader, ...)` | ⚠️ Pre-load required | `gt = await reader.load(); read.read_reproject(gt, ...)` |\n",
+    "| `read.read_reproject_like(reader, template)` | ⚠️ Pre-load required | `gt = await reader.load(); read.read_reproject_like(gt, template)` |\n",
+    "| `read.read_to_crs(reader, dst_crs)` | ⚠️ Pre-load required | `gt = await reader.load(); read.read_to_crs(gt, dst_crs)` |\n",
+    "| `return_only_data=True` on any of the above | ❌ Not supported | `await view.load(); gt.values` instead |\n",
+    "| `trigger_load=True` on any of the above | ❌ Not supported | Just `await view.load()` instead |\n",
+    "\n",
+    "**Why the split:**\n",
+    "\n",
+    "- The ✅ functions return a lazy reader view; the actual I/O only happens\n",
+    "  when you `await view.load()`. Same code path as the sync side, except\n",
+    "  the final materialisation hop is async.\n",
+    "- The ⚠️ functions materialise source data internally before the\n",
+    "  return-value `GeoTensor` is built. `read.read_reproject` /\n",
+    "  `read.read_reproject_like` / `read.read_to_crs` use\n",
+    "  `rasterio.warp.reproject` (numpy-array input).\n",
+    "  `read.read_from_tile` falls through to `read.read_reproject`\n",
+    "  internally when the reader does not expose its own `read_from_tile`\n",
+    "  method (`RasterioReader` does, `AsyncGeoTIFFReader` does not). All\n",
+    "  of these short-circuit via `isinstance(data_in, GeoTensor)`, so\n",
+    "  handing them a pre-loaded `GeoTensor` is the canonical async\n",
+    "  pattern. No `aread_*` siblings exist or are needed.\n",
+    "- The ❌ flags trigger a sync `.values` or `.load()` call on the view,\n",
+    "  which for async readers returns a coroutine instead of a numpy array.\n",
+    "  Always materialise via `await view.load()` first.\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
-   "id": "6efef835",
+   "execution_count": 11,
+   "id": "ef3f4b8e",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:03.142037Z",
-     "iopub.status.busy": "2026-05-14T16:10:03.141976Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.143668Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.143485Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.200467Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.200409Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.202658Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.202476Z"
     }
    },
    "outputs": [
@@ -630,47 +833,151 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "NotImplementedError: AsyncGeoTIFFReader does not warp or resample. Read in the native CRS, then call georeader.read.read_reproject_like, or use RasterioReader for WarpedVRT-based on-the-fly warping.\n"
+      "View type:  AsyncGeoTIFFReader\n",
+      "View shape: (3, 48, 64)\n",
+      "No I/O has happened yet — the bytes only travel on .load()\n",
+      "After load: shape=(3, 48, 64), type=GeoTensor\n"
      ]
     }
    ],
    "source": [
-    "try:\n",
-    "    await reader.read_from_bounds(reader.bounds, target_crs=\"EPSG:4326\")\n",
-    "except NotImplementedError as e:\n",
-    "    print(f\"NotImplementedError: {e}\")\n"
+    "# Pattern 1: read.read_from_window — sync view, async load.\n",
+    "from georeader import read\n",
+    "\n",
+    "view = read.read_from_window(reader, win)\n",
+    "print(f\"View type:  {type(view).__name__}\")\n",
+    "print(f\"View shape: {view.shape}\")\n",
+    "print(f\"No I/O has happened yet — the bytes only travel on .load()\")\n",
+    "\n",
+    "gt = await view.load()\n",
+    "print(f\"After load: shape={gt.values.shape}, type={type(gt).__name__}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "6588a1a0",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-18T06:28:07.203521Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.203469Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.212360Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.212198Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Native bounds:  shape=(3, 24, 32), crs=EPSG:32631\n",
+      "Bounds in WGS84: shape=(3, 26, 33), crs=EPSG:32631\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Pattern 2: read.read_from_bounds — geographic bounds, with optional CRS reprojection\n",
+    "# of the bounds (the data stays in the reader's native CRS).\n",
+    "import rasterio.warp\n",
+    "\n",
+    "# Native-CRS bounds (UTM 31N for this fixture)\n",
+    "utm_bounds = (500080.0, 4599720.0, 500400.0, 4599960.0)\n",
+    "gt_native = await read.read_from_bounds(reader, utm_bounds).load()\n",
+    "print(f\"Native bounds:  shape={gt_native.values.shape}, crs={gt_native.crs}\")\n",
+    "\n",
+    "# WGS84 bounds — read.read_from_bounds reprojects the bounds, not the data.\n",
+    "# Result is still in the reader's native CRS.\n",
+    "wgs_bounds = rasterio.warp.transform_bounds(reader.crs, \"EPSG:4326\", *utm_bounds)\n",
+    "gt_from_wgs = await read.read_from_bounds(reader, wgs_bounds, crs_bounds=\"EPSG:4326\").load()\n",
+    "print(f\"Bounds in WGS84: shape={gt_from_wgs.values.shape}, crs={gt_from_wgs.crs}\")\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "9d7ea285",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-18T06:28:07.213208Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.213153Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.253775Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.253568Z"
+    }
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Pre-loaded:      shape=(3, 256, 256), crs=EPSG:32631\n",
+      "After reproject: shape=(3, 218, 290), crs=EPSG:4326\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Pattern 3: read.read_reproject — pre-load, then reproject the in-memory GeoTensor.\n",
+    "#\n",
+    "# read.read_reproject(data_in, ...) checks `isinstance(data_in, GeoTensor)`\n",
+    "# and skips its internal sync materialisation when the input is already in\n",
+    "# memory. So the async pattern is: await load() once, then call read_reproject\n",
+    "# (or read_to_crs / read_reproject_like) normally.\n",
+    "gt_native = await reader.load()\n",
+    "gt_wgs84 = read.read_to_crs(gt_native, dst_crs=\"EPSG:4326\")\n",
+    "print(f\"Pre-loaded:      shape={gt_native.values.shape}, crs={gt_native.crs}\")\n",
+    "print(f\"After reproject: shape={gt_wgs84.values.shape}, crs={gt_wgs84.crs}\")\n"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "0d0644d5",
+   "id": "3935d2f6",
    "metadata": {},
    "source": [
-    "### Mini-solution: warp / reproject **after** loading\n",
+    "## Bandwidth-conscious tile reads — without pre-loading the whole raster\n",
     "\n",
-    "When you need a different CRS or resolution, the recommended pattern is\n",
-    "**fetch native, then warp post-step** via georeader's sync warp helpers. Two\n",
-    "shapes cover most cases:\n",
+    "`read.read_from_tile` is in the ⚠️ pre-load column above, which means\n",
+    "the \"obvious\" async pattern (`gt = await reader.load();\n",
+    "read.read_from_tile(gt, x, y, z)`) reads the **entire COG** over the\n",
+    "network just to serve one 256×256 tile. For a tile server that\n",
+    "defeats the whole point of going async — most of those bytes are\n",
+    "discarded after the reproject.\n",
     "\n",
-    "- **`read.read_to_crs(gt, dst_crs=...)`** &mdash; reproject a loaded\n",
-    "  `GeoTensor` to a target CRS with a derived transform.\n",
-    "- **`read.read_reproject_like(gt, gt_target)`** &mdash; reproject onto the\n",
-    "  exact grid of another `GeoTensor` (matching extent, resolution, CRS).\n",
+    "The fix is to compose from primitives. The ✅ functions (`read_from_bounds`,\n",
+    "`read_from_polygon`) are bandwidth-efficient by design — they fetch only\n",
+    "the windowed region. Combine one of them with `read.read_to_crs` as a\n",
+    "sync post-step on the small chip:\n",
     "\n",
-    "Both are sync and use `rasterio.warp` under the hood (which means they pull\n",
-    "GDAL into the dependency cone &mdash; that is the cost of warping)."
+    "**Scale caveat for the demo below.** The 256×256 fixture is small,\n",
+    "so the bandwidth ratio you'll see is modest (~2×). The pattern is\n",
+    "meant for production tile servers fronting large COGs — a single\n",
+    "Sentinel-2 L2A band at 10,980×10,980 is ~230 MB; fetching just the\n",
+    "tile-region for a 256×256 web-mercator tile is ~1 MB. **~200× less**\n",
+    "bytes-over-the-wire per tile.\n",
+    "\n",
+    "1. Compute the tile's bounds in EPSG:3857 (`mercantile.xy_bounds`).\n",
+    "2. Reproject the *bounds* (not the data) into the reader's native CRS.\n",
+    "3. `await reader.read_from_bounds(bounds_native).load()` — fetches\n",
+    "   **only** the tile-region bytes from the COG. This is the async I/O\n",
+    "   step.\n",
+    "4. `read.read_to_crs(chip, dst_crs=\"EPSG:3857\")` — sync warp of the\n",
+    "   small chip. Fast (`rasterio.warp` on a tile-sized array) and pulls\n",
+    "   no extra bytes.\n",
+    "5. Optional: resize to a standard tile size with `chip.resize(...)`.\n",
+    "\n",
+    "This is the same bytes-over-the-wire cost as a hypothetical\n",
+    "`reader.read_from_tile()` async method would be — no new API surface,\n",
+    "just clearer composition.\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "id": "53325ccd",
+   "execution_count": 14,
+   "id": "c8c48112",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:03.144586Z",
-     "iopub.status.busy": "2026-05-14T16:10:03.144529Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.184328Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.184105Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.254868Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.254809Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.269374Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.269175Z"
     }
    },
    "outputs": [
@@ -678,15 +985,136 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Native: crs=EPSG:32631, shape=(3, 256, 256), transform=| 10.00, 0.00, 500000.00|\n",
-      "| 0.00,-10.00, 4600000.00|\n",
-      "| 0.00, 0.00, 1.00|\n"
+      "Tile (z=14, x=8328, y=6109)\n",
+      "  native-CRS bounds: (499022.5, 4598869.1, 500855.3, 4600694.7)\n",
+      "  raster bounds:     (500000.0, 4597440.0, 502560.0, 4600000.0)\n",
+      "\n",
+      "Fetched chip:\n",
+      "  shape: (3, 184, 184)   ← only the tile-relevant region\n",
+      "  bytes in flight (chip): 203,136\n",
+      "  vs pre-load (whole COG): 393,216  (1.9× larger)\n",
+      "\n",
+      "Reprojected tile:\n",
+      "  crs:   EPSG:3857\n",
+      "  shape: (3, 184, 184)\n",
+      "  bounds match the requested tile: True\n"
      ]
-    },
+    }
+   ],
+   "source": [
+    "# Bandwidth-conscious tile reads from primitives.\n",
+    "import mercantile\n",
+    "import rasterio.warp\n",
+    "\n",
+    "# Pick an XYZ tile that covers (part of) the fixture. The fixture is at\n",
+    "# (3.0°E, 41.55°N) in UTM 31N, so a z=14 tile in that area works.\n",
+    "lon, lat = 3.0029, 41.5502\n",
+    "z = 14\n",
+    "n = 2 ** z\n",
+    "xtile = int((lon + 180.0) / 360.0 * n)\n",
+    "import math as _math\n",
+    "ytile = int((1.0 - _math.log(_math.tan(_math.radians(lat)) + 1.0 / _math.cos(_math.radians(lat))) / _math.pi) / 2.0 * n)\n",
+    "\n",
+    "# 1. Tile bounds in Web Mercator (3857).\n",
+    "tile_bounds_3857 = mercantile.xy_bounds(xtile, ytile, z)\n",
+    "\n",
+    "# 2. Reproject tile bounds into the reader's native CRS (just the bounds —\n",
+    "#    the data stays where it is).\n",
+    "tile_bounds_native = rasterio.warp.transform_bounds(\n",
+    "    \"EPSG:3857\", reader.crs,\n",
+    "    tile_bounds_3857.left, tile_bounds_3857.bottom,\n",
+    "    tile_bounds_3857.right, tile_bounds_3857.top,\n",
+    ")\n",
+    "print(f\"Tile (z={z}, x={xtile}, y={ytile})\")\n",
+    "print(f\"  native-CRS bounds: {tuple(round(v, 1) for v in tile_bounds_native)}\")\n",
+    "print(f\"  raster bounds:     {tuple(round(v, 1) for v in reader.bounds)}\")\n",
+    "\n",
+    "# 3. Fetch ONLY the tile-relevant window from the COG. This is the async\n",
+    "#    I/O step. The view itself is constructed sync (no I/O); load() does\n",
+    "#    the fetch.\n",
+    "chip = await read.read_from_bounds(reader, tile_bounds_native).load()\n",
+    "print(f\"\\nFetched chip:\")\n",
+    "print(f\"  shape: {chip.values.shape}   ← only the tile-relevant region\")\n",
+    "print(f\"  bytes in flight (chip): {chip.values.nbytes:,}\")\n",
+    "print(f\"  vs pre-load (whole COG): {reader.shape[0] * reader.shape[1] * reader.shape[2] * 2:,}  ({(reader.shape[0] * reader.shape[1] * reader.shape[2] * 2) / chip.values.nbytes:.1f}× larger)\")\n",
+    "\n",
+    "# 4. Sync reproject the SMALL chip to 3857.\n",
+    "tile_gt = read.read_to_crs(chip, dst_crs=\"EPSG:3857\")\n",
+    "print(f\"\\nReprojected tile:\")\n",
+    "print(f\"  crs:   {tile_gt.crs}\")\n",
+    "print(f\"  shape: {tile_gt.values.shape}\")\n",
+    "print(f\"  bounds match the requested tile: {tile_gt.bounds[0] != reader.bounds[0]}\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "6669f64f",
+   "metadata": {},
+   "source": [
+    "## What this reader does NOT do\n",
+    "\n",
+    "`async-geotiff` explicitly disclaims warp / resample / overview\n",
+    "auto-selection. `AsyncGeoTIFFReader` follows the same boundary by design.\n",
+    "\n",
+    "- **No on-the-fly CRS warp.** No equivalent of\n",
+    "  `RasterioReader`'s WarpedVRT. Use the pre-load pattern from the\n",
+    "  previous section: `gt = await reader.load(); read.read_to_crs(gt, ...)`.\n",
+    "- **No on-the-fly resampling.** Reading at a different resolution means\n",
+    "  reading the nearest overview level (`overview_level=N` in the\n",
+    "  constructor) and accepting that grid, or post-resampling via\n",
+    "  `gt.resize(...)` after `load()`.\n",
+    "- **No automatic overview selection.** You pick the overview level\n",
+    "  explicitly; the reader won't guess based on a target resolution.\n",
+    "- **No band-select primitive.** `async-geotiff` reads all bands as a unit.\n",
+    "  Post-load slice the resulting `GeoTensor` if you only want some bands.\n",
+    "- **Not pickleable across processes.** The cached `_geotiff` handle\n",
+    "  doesn't survive a `multiprocessing` / `joblib` / Dask worker boundary.\n",
+    "  For multi-process use `RasterioReader`.\n",
+    "- **TIFF/COG only.** `async-geotiff` parses files as TIFF and rejects\n",
+    "  anything else. JP2 (the Sentinel-2 native L1C format), NetCDF, HDF5,\n",
+    "  GRIB all require `RasterioReader`. The JP2 case in particular is\n",
+    "  worth calling out — opening a `.jp2` raises\n",
+    "  `AsyncTiffException: unexpected magic bytes`.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e74e98d7",
+   "metadata": {},
+   "source": [
+    "### Mini-solution: warp / reproject **after** loading\n",
+    "\n",
+    "When you need a different CRS or resolution, the recommended pattern is\n",
+    "**fetch native, then warp as a sync post-step** via georeader's `read.*`\n",
+    "helpers:\n",
+    "\n",
+    "- **`read.read_to_crs(gt, dst_crs=...)`** — reproject a loaded\n",
+    "  `GeoTensor` to a target CRS with a derived transform.\n",
+    "- **`read.read_reproject_like(gt, gt_target)`** — reproject onto the\n",
+    "  exact grid of another `GeoTensor` (matching extent, resolution, CRS).\n",
+    "\n",
+    "Both are sync and use `rasterio.warp` under the hood (which means they pull\n",
+    "GDAL into the dependency cone — that is the cost of warping).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "ead067ea",
+   "metadata": {
+    "execution": {
+     "iopub.execute_input": "2026-05-18T06:28:07.270491Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.270422Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.300261Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.300053Z"
+    }
+   },
+   "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
+      "Native: crs=EPSG:32631, shape=(3, 256, 256)\n",
       "Warped to WGS84: crs=EPSG:4326, shape=(3, 218, 290)\n"
      ]
     }
@@ -694,25 +1122,23 @@
    "source": [
     "# 1. Read native CRS via the async reader\n",
     "gt_native = await reader.load()\n",
-    "print(f\"Native: crs={gt_native.crs}, shape={gt_native.values.shape}, transform={gt_native.transform}\")\n",
+    "print(f\"Native: crs={gt_native.crs}, shape={gt_native.values.shape}\")\n",
     "\n",
     "# 2a. Warp to a target CRS (sync post-step)\n",
-    "from georeader import read\n",
-    "\n",
     "gt_wgs84 = read.read_to_crs(gt_native, dst_crs=\"EPSG:4326\")\n",
     "print(f\"Warped to WGS84: crs={gt_wgs84.crs}, shape={gt_wgs84.values.shape}\")\n"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
-   "id": "438e0a27",
+   "execution_count": 16,
+   "id": "3f4bfd47",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:03.185525Z",
-     "iopub.status.busy": "2026-05-14T16:10:03.185453Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.208690Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.208424Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.301233Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.301172Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.321786Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.321604Z"
     }
    },
    "outputs": [
@@ -728,8 +1154,6 @@
    ],
    "source": [
     "# 2b. Reproject onto another GeoTensor's grid (e.g. for stack alignment)\n",
-    "from georeader.geotensor import GeoTensor\n",
-    "\n",
     "target_grid = GeoTensor(\n",
     "    values=np.zeros((3, 200, 200), dtype=np.int16),\n",
     "    transform=from_origin(500000.0, 4600000.0, 12.0, 12.0),  # 12m pixels instead of 10m\n",
@@ -742,37 +1166,41 @@
   },
   {
    "cell_type": "markdown",
-   "id": "719240d9",
+   "id": "12a7335d",
    "metadata": {},
    "source": [
     "## Tips and gotchas\n",
     "\n",
-    "- **Two-phase laziness.** Header on `open()`, pixels on `read()`. Properties\n",
+    "- **Two-phase laziness.** Header on `open()`, pixels on `load()`. Properties\n",
     "  raise `RuntimeError` before `open()`. Use `async with` if you want to skip\n",
     "  the explicit `open` + `aclose` dance.\n",
-    "- **Not pickleable across processes.** The `_geotiff` handle is alive\n",
-    "  between reads (faster repeated reads) but won't survive a\n",
-    "  `multiprocessing` / `joblib` / Dask worker boundary. For multi-process,\n",
-    "  open the reader fresh in each worker, or use `RasterioReader`.\n",
-    "- **`store=` is required &mdash; no default.** Pick the right `obstore` Store per\n",
+    "- **Sync view + async load.** `reader.read_from_window(w)` is sync and\n",
+    "  returns a windowed view (no I/O). `await view.load()` does the fetch.\n",
+    "  This is what makes the reader compose with the entire `read.*` module —\n",
+    "  see the compatibility section above.\n",
+    "- **Fan out via `gather`.** Building the views is instant; the concurrency\n",
+    "  lives in `asyncio.gather(*[v.load() for v in views])`.\n",
+    "- **Tile-align when you can.** Reading on tile boundaries\n",
+    "  (`reader.block_windows()`) avoids partial-tile fetches over the wire.\n",
+    "- **Pre-load for reproject.** `read.read_reproject` / `read_reproject_like` /\n",
+    "  `read_to_crs` need a `GeoTensor` (the in-memory short-circuit at\n",
+    "  `read.py:1605`). Call `gt = await reader.load()` once and pass `gt` in.\n",
+    "- **Not pickleable.** Open the reader fresh in each worker, or use\n",
+    "  `RasterioReader` for `multiprocessing`/Dask.\n",
+    "- **`store=` is required — no default.** Pick the right `obstore` store per\n",
     "  cloud:\n",
     "  - `obstore.store.S3Store(bucket=..., region=...)` for AWS S3\n",
     "  - `obstore.store.GCSStore(bucket=..., ...)` for Google Cloud Storage\n",
     "  - `obstore.store.AzureStore(container_name=..., ...)` for Azure Blob\n",
     "  - `obstore.store.LocalStore(prefix=dir)` for local disk\n",
     "  - `obstore.store.HTTPStore.from_url(url)` for HTTPS\n",
-    "- **Overviews.** `overview_level=None` (default) reads full resolution;\n",
-    "  `overview_level=i` reads the i-th overview (0-based). The COG must\n",
-    "  actually have overviews — `overview_level=0` on a non-overview file\n",
-    "  raises `IndexError`. Auto-picking the right level for a target resolution\n",
-    "  isn't done for you; pick explicitly based on `len(reader._geotiff.overviews)`.\n",
-    "- **TIFF/COG only.** For JP2, NetCDF, HDF5, GRIB, use `RasterioReader`.\n",
+    "- **Overviews are explicit.** `reader.overviews()` lists what's available;\n",
+    "  `reader.reader_overview(level)` (or `overview_level=N` at construction)\n",
+    "  pins a level. No auto-selection.\n",
+    "- **TIFF/COG only.** JP2, NetCDF, HDF5, GRIB → use `RasterioReader`.\n",
     "- **Mask convention.** `async-geotiff`'s `RasterArray.mask` uses\n",
-    "  `True = valid` (inverse of numpy MA's convention). The adapter handles\n",
-    "  this and substitutes `fill_value_default` where invalid.\n",
-    "- **No warp / resample / overview auto-selection.** Use the mini-solution\n",
-    "  above (load native + `read.read_to_crs` / `read.read_reproject_like`), or\n",
-    "  reach for `RasterioReader` with WarpedVRT for one-shot on-the-fly warping.\n"
+    "  `True = valid` (inverse of numpy MA). The adapter handles this and\n",
+    "  substitutes `fill_value_default` where invalid.\n"
    ]
   },
   {
@@ -817,14 +1245,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 17,
    "id": "2835076c",
    "metadata": {
     "execution": {
-     "iopub.execute_input": "2026-05-14T16:10:03.209920Z",
-     "iopub.status.busy": "2026-05-14T16:10:03.209848Z",
-     "iopub.status.idle": "2026-05-14T16:10:03.211685Z",
-     "shell.execute_reply": "2026-05-14T16:10:03.211393Z"
+     "iopub.execute_input": "2026-05-18T06:28:07.322813Z",
+     "iopub.status.busy": "2026-05-18T06:28:07.322758Z",
+     "iopub.status.idle": "2026-05-18T06:28:07.324407Z",
+     "shell.execute_reply": "2026-05-18T06:28:07.324196Z"
     }
    },
    "outputs": [],
diff --git a/docs/read_S2_SAFE_from_bucket.ipynb b/docs/read_S2_SAFE_from_bucket.ipynb
index d97eeec..d8e8c2a 100644
--- a/docs/read_S2_SAFE_from_bucket.ipynb
+++ b/docs/read_S2_SAFE_from_bucket.ipynb
@@ -7,7 +7,7 @@
    "source": [
     "## Read Sentinel-2 files from public bucket\n",
     "\n",
-    "* Author: Gonzalo Mateo-Garc\u00eda\n",
+    "* Author: Gonzalo Mateo-García\n",
     "\n",
     "This notebook shows how to read a Sentinel-2 SAFE file from the public Google bucket and reading a subset of it."
    ]
@@ -62,7 +62,7 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      "100%|\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588| 13/13 [00:00<00:00, 26341.04it/s]"
+      "100%|██████████| 13/13 [00:00<00:00, 26341.04it/s]"
      ]
     },
     {
@@ -193,8 +193,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "CPU times: user 10 \u00b5s, sys: 0 ns, total: 10 \u00b5s\n",
-      "Wall time: 18.6 \u00b5s\n"
+      "CPU times: user 10 µs, sys: 0 ns, total: 10 µs\n",
+      "Wall time: 18.6 µs\n"
      ]
     },
     {
@@ -308,17 +308,18 @@
   },
   {
    "cell_type": "markdown",
+   "id": "27671b69",
    "metadata": {},
    "source": [
     "## Alternative bytes paths via `RasterioReader`\n",
     "\n",
-    "The high-level `S2_SAFE_reader` above routes bytes through GDAL VSI (libcurl in C) by default \u2014 the fastest sync path for public cloud buckets. For workloads that need a different bytes transport (custom auth, niche backends, a Python-side adapter), `RasterioReader` exposes three keyword-only knobs:\n",
+    "The high-level `S2_SAFE_reader` above routes bytes through GDAL VSI (libcurl in C) by default — the fastest sync path for public cloud buckets. For workloads that need a different bytes transport (custom auth, niche backends, a Python-side adapter), `RasterioReader` exposes three keyword-only knobs:\n",
     "\n",
-    "- `opener=callable` \u2014 passed straight to `rasterio.open(opener=...)`. Signature: `opener(path, mode='rb') -> file-like`.\n",
-    "- `fs=fsspec.AbstractFileSystem` \u2014 shortcut for `opener=fs.open`. Useful for FTP / SFTP / GitHub / MinIO with custom auth.\n",
-    "- `rio_open_kwargs=dict` \u2014 escape hatch for arbitrary additional kwargs.\n",
+    "- `opener=callable` — passed straight to `rasterio.open(opener=...)`. Signature: `opener(path, mode='rb') -> file-like`.\n",
+    "- `fs=fsspec.AbstractFileSystem` — shortcut for `opener=fs.open`. Useful for FTP / SFTP / GitHub / MinIO with custom auth.\n",
+    "- `rio_open_kwargs=dict` — escape hatch for arbitrary additional kwargs.\n",
     "\n",
-    "Sketch (pseudocode \u2014 replace with a path and credentials you have access to):\n",
+    "Sketch (pseudocode — replace with a path and credentials you have access to):\n",
     "\n",
     "```python\n",
     "from georeader.rasterio_reader import RasterioReader\n",
@@ -344,34 +345,77 @@
   },
   {
    "cell_type": "markdown",
+   "id": "9bbf0752",
    "metadata": {},
    "source": [
-    "## Async alternative \u2014 `AsyncGeoTIFFReader` for high-concurrency reads\n",
-    "\n",
-    "`S2_SAFE_reader` and the `opener=` / `fs=` knobs above are **sync** \u2014 one read at a time. For workloads that fan out many concurrent reads from one process (a tile server serving S2 chips, an async ML inference service), `AsyncGeoTIFFReader` + `asyncio.gather` is the right shape. It is COG-only (good for the per-band JP2/TIFF granules; not for the SAFE XML metadata), takes any `obspec.AsyncStore` (`obstore.GCSStore` here), and skips GDAL entirely on the read path.\n",
-    "\n",
-    "Sketch (pseudocode \u2014 needs real bucket coordinates and credentials):\n",
-    "\n",
-    "```python\n",
+    "## Async alternative — `AsyncGeoTIFFReader` for high-concurrency reads\n",
+    "\n",
+    "`S2_SAFE_reader` and the `opener=` / `fs=` knobs above are **sync** — one\n",
+    "read at a time. For workloads that fan out many concurrent reads from one\n",
+    "process (a tile server serving S2 chips, an async ML inference service),\n",
+    "`AsyncGeoTIFFReader` + `asyncio.gather` is the right shape.\n",
+    "\n",
+    "**Important limitation: this reader does not work with the JP2 bands in\n",
+    "the SAFE archive.** `AsyncGeoTIFFReader` is a thin adapter over\n",
+    "[`developmentseed/async-geotiff`](https://github.com/developmentseed/async-geotiff),\n",
+    "which parses files as **TIFF only**. Opening a `.jp2` from the SAFE\n",
+    "archive raises `AsyncTiffException: unexpected magic bytes`. Sentinel-2\n",
+    "L1C is published as JP2 in the SAFE archive — for that format you must\n",
+    "use `RasterioReader` (which routes through GDAL's JP2 driver).\n",
+    "\n",
+    "If you want **async** Sentinel-2 access, switch buckets: the\n",
+    "[Element 84 `sentinel-cogs` bucket on AWS](https://registry.opendata.aws/sentinel-2-l2a-cogs/)\n",
+    "hosts L2A scenes as **per-band Cloud-Optimized GeoTIFFs**, which\n",
+    "`AsyncGeoTIFFReader` reads natively. The cell below demonstrates the\n",
+    "actual working flow against a public L2A scene — anonymous read, no\n",
+    "credentials needed.\n",
+    "\n",
+    "For the full `AsyncGeoTIFFReader` tutorial (two-phase laziness,\n",
+    "overviews, fan-out patterns, `read.*` polymorphism, warp-after-load),\n",
+    "see [`advanced/async_geotiff_reader.ipynb`](advanced/async_geotiff_reader.ipynb).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "954fe0d2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Runnable example: async reads of an Element 84 L2A scene (per-band COGs).\n",
+    "# The bucket is anonymously readable, so no credentials are needed — but\n",
+    "# you need network access for this cell to execute.\n",
     "import asyncio\n",
-    "from obstore.store import GCSStore\n",
-    "from georeader.async_geotiff_reader import AsyncGeoTIFFReader\n",
     "\n",
-    "# An obstore store rooted at the public Sentinel-2 GCS bucket\n",
-    "store = GCSStore(bucket=\"gcp-public-data-sentinel-2\", skip_signature=True)\n",
+    "import rasterio.windows\n",
+    "from obstore.store import S3Store\n",
     "\n",
-    "# One reader per granule; in tile-server use these are cached in an LRU.\n",
-    "reader = await AsyncGeoTIFFReader.open(\"path/to/B04.jp2\", store=store)\n",
-    "\n",
-    "# Fan out across N windows of one granule:\n",
-    "chips = await asyncio.gather(*[reader.read_from_window(w) for w in windows])\n",
-    "\n",
-    "# Or across N granules concurrently:\n",
-    "readers = await asyncio.gather(*[AsyncGeoTIFFReader.open(p, store=store) for p in paths])\n",
-    "scenes = await asyncio.gather(*[r.load() for r in readers])\n",
-    "```\n",
+    "from georeader.async_geotiff_reader import AsyncGeoTIFFReader\n",
     "\n",
-    "See [`advanced/async_geotiff_reader.ipynb`](advanced/async_geotiff_reader.ipynb) for the full tutorial, diagrams, and a mini-solution for warp-after-load.\n"
+    "# A stable public scene from the L2A COG bucket (MGRS T49SGV, May 2022).\n",
+    "store = S3Store(bucket=\"sentinel-cogs\", region=\"us-west-2\", skip_signature=True)\n",
+    "scene_prefix = \"sentinel-s2-l2a-cogs/49/S/GV/2022/5/S2B_49SGV_20220527_0_L2A\"\n",
+    "band_paths = [f\"{scene_prefix}/B04.tif\", f\"{scene_prefix}/B03.tif\", f\"{scene_prefix}/B02.tif\"]\n",
+    "\n",
+    "# Open one reader per band concurrently (each open() = one HEAD-ish IFD fetch)\n",
+    "readers = await asyncio.gather(\n",
+    "    *[AsyncGeoTIFFReader.open(p, store=store) for p in band_paths]\n",
+    ")\n",
+    "print(f\"Opened {len(readers)} band readers\")\n",
+    "print(f\"  B04 shape: {readers[0].shape}, crs: {readers[0].crs}, res: {readers[0].res}\")\n",
+    "\n",
+    "# Fan out 16 concurrent 256x256 window reads, one window per band, mixed\n",
+    "windows = [\n",
+    "    rasterio.windows.Window(col_off=5000 + (i % 4) * 256,\n",
+    "                            row_off=5000 + (i // 4) * 256,\n",
+    "                            width=256, height=256)\n",
+    "    for i in range(16)\n",
+    "]\n",
+    "chips = await asyncio.gather(\n",
+    "    *[readers[i % 3].read_from_window(w).load() for i, w in enumerate(windows)]\n",
+    ")\n",
+    "print(f\"Fetched {len(chips)} chips across 3 bands concurrently from one event loop\")\n",
+    "print(f\"  first chip shape: {chips[0].values.shape}\")\n"
    ]
   },
   {
@@ -395,7 +439,7 @@
     "\tnumber = {1},\n",
     "\turldate = {2023-11-30},\n",
     "\tjournal = {Scientific Reports},\n",
-    "\tauthor = {Portal\u00e9s-Juli\u00e0, Enrique and Mateo-Garc\u00eda, Gonzalo and Purcell, Cormac and G\u00f3mez-Chova, Luis},\n",
+    "\tauthor = {Portalés-Julià, Enrique and Mateo-García, Gonzalo and Purcell, Cormac and Gómez-Chova, Luis},\n",
     "\tmonth = nov,\n",
     "\tyear = {2023},\n",
     "\tpages = {20316},\n",
diff --git a/georeader/async_geotiff_reader.py b/georeader/async_geotiff_reader.py
index 1d119db..e8ddf9a 100644
--- a/georeader/async_geotiff_reader.py
+++ b/georeader/async_geotiff_reader.py
@@ -2,12 +2,17 @@
 Async COG reader: thin adapter over ``developmentseed/async-geotiff``.
 
 This module provides :class:`AsyncGeoTIFFReader`, an ``async``-native reader
-for Cloud-Optimized GeoTIFFs (COGs). It is a thin (~80-LOC) adapter on top of
+for Cloud-Optimized GeoTIFFs (COGs). It is a thin adapter on top of
 `async-geotiff <https://github.com/developmentseed/async-geotiff>`_ that
-exposes the same metadata surface as :class:`~georeader.rasterio_reader.RasterioReader`
-and conforms to :class:`~georeader.abstract_reader.AsyncGeoData`. Use it for
-high-concurrency fan-out workloads (tile servers, async ML inference) where
-many reads happen concurrently from one process.
+provides the :class:`~georeader.abstract_reader.AsyncGeoData` protocol,
+the lazy windowed-view pattern that mirrors
+:class:`~georeader.rasterio_reader.RasterioReader`, and translation
+between georeader's ``GeoTensor`` / ``rasterio.windows.Window`` carriers
+and async-geotiff's ``RasterArray`` / ``Window`` types. The actual IFD
+walk, tile-fetch math, decompression, and request coalescing all live
+upstream. Use it for high-concurrency fan-out workloads (tile servers,
+async ML inference) where many reads happen concurrently from one
+process.
 
 Sync vs Async
 -------------
diff --git a/georeader/read.py b/georeader/read.py
index 8e1dc65..6438642 100644
--- a/georeader/read.py
+++ b/georeader/read.py
@@ -1831,8 +1831,7 @@ def read_from_tile(
 
     if not intersects:
         assert not assert_if_not_intersects, "Tile does not intersect data"
-    else:
-        return
+        return  # Non-intersecting tile — return None (standard tile-server behaviour)
 
     if out_shape is not None and hasattr(data, "read_from_tile"):
         return data.read_from_tile(x, y, z, dst_crs=dst_crs, out_shape=out_shape)
diff --git a/notebooks/Sentinel-2/read_s2_safe_element84_cloud.ipynb b/notebooks/Sentinel-2/read_s2_safe_element84_cloud.ipynb
index bd8dbc1..b518932 100644
--- a/notebooks/Sentinel-2/read_s2_safe_element84_cloud.ipynb
+++ b/notebooks/Sentinel-2/read_s2_safe_element84_cloud.ipynb
@@ -6451,6 +6451,75 @@
     "    \n",
     "    "
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Async fan-out — concurrent reads with `AsyncGeoTIFFReader`\n",
+    "\n",
+    "The Element 84 `sentinel-cogs` bucket serves L2A scenes as **per-band\n",
+    "Cloud-Optimized GeoTIFFs** (one TIFF per band, not the JP2-based SAFE\n",
+    "layout). That makes them a perfect fit for `AsyncGeoTIFFReader`, which\n",
+    "is COG-only and shines when you fan out many reads concurrently from\n",
+    "one process.\n",
+    "\n",
+    "This cell opens three band readers in parallel against the same scene\n",
+    "used above (anonymous S3 read, no credentials), then issues 16\n",
+    "concurrent window reads across them with `asyncio.gather`. The pattern\n",
+    "generalises to tile-server workloads serving Sentinel-2 chips: cache\n",
+    "one reader per granule, fan out window reads per request.\n",
+    "\n",
+    "For the full tutorial (two-phase laziness, overviews, tile-aligned\n",
+    "fan-out via `block_windows`, `read.*` polymorphism, warp-after-load),\n",
+    "see [`docs/advanced/async_geotiff_reader.ipynb`](../../docs/advanced/async_geotiff_reader.ipynb).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import asyncio\n",
+    "\n",
+    "import rasterio.windows\n",
+    "from obstore.store import S3Store\n",
+    "\n",
+    "from georeader.async_geotiff_reader import AsyncGeoTIFFReader\n",
+    "\n",
+    "# Anonymous read of the L2A COG bucket — same data we queried above,\n",
+    "# but reached through obstore (async) rather than pystac + rasterio (sync).\n",
+    "store = S3Store(bucket=\"sentinel-cogs\", region=\"us-west-2\", skip_signature=True)\n",
+    "\n",
+    "# Use the same scene the cells above queried. The Element 84 STAC item's\n",
+    "# asset hrefs look like \"https://sentinel-cogs.s3.us-west-2.amazonaws.com/...\"\n",
+    "# — strip the bucket URL to get the path inside the bucket.\n",
+    "scene_prefix = \"sentinel-s2-l2a-cogs/49/S/GV/2022/5/S2B_49SGV_20220527_0_L2A\"\n",
+    "band_paths = [f\"{scene_prefix}/B04.tif\",\n",
+    "              f\"{scene_prefix}/B03.tif\",\n",
+    "              f\"{scene_prefix}/B02.tif\"]\n",
+    "\n",
+    "# Open the band headers concurrently (each open() = one IFD fetch).\n",
+    "readers = await asyncio.gather(\n",
+    "    *[AsyncGeoTIFFReader.open(p, store=store) for p in band_paths]\n",
+    ")\n",
+    "print(f\"Opened {len(readers)} band readers concurrently\")\n",
+    "print(f\"  B04 metadata: shape={readers[0].shape}, crs={readers[0].crs}, res={readers[0].res}\")\n",
+    "\n",
+    "# Fan out 16 concurrent window reads across the three bands.\n",
+    "windows = [\n",
+    "    rasterio.windows.Window(col_off=5000 + (i % 4) * 256,\n",
+    "                            row_off=5000 + (i // 4) * 256,\n",
+    "                            width=256, height=256)\n",
+    "    for i in range(16)\n",
+    "]\n",
+    "chips = await asyncio.gather(\n",
+    "    *[readers[i % 3].read_from_window(w).load() for i, w in enumerate(windows)]\n",
+    ")\n",
+    "print(f\"Fetched {len(chips)} chips concurrently from one event loop\")\n",
+    "print(f\"  first chip shape: {chips[0].values.shape}\")\n"
+   ]
   }
  ],
  "metadata": {
diff --git a/notebooks/read_from_tileserver.ipynb b/notebooks/read_from_tileserver.ipynb
index 5521d47..621384c 100644
--- a/notebooks/read_from_tileserver.ipynb
+++ b/notebooks/read_from_tileserver.ipynb
@@ -106,126 +106,6 @@
     "plot.add_shape_to_plot(aoi, crs_plot=output.crs, crs_shape=\"EPSG:4326\", polygon_no_fill=True)"
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "e2ec990f",
-   "metadata": {},
-   "source": [
-    "## Async alternative — `AsyncGeoTIFFReader` against a public COG\n",
-    "\n",
-    "The tile-server example above reads stitched XYZ tiles via HTTP (the\n",
-    "common tile-server protocol). For COG sources — files written once and\n",
-    "served with HTTP range requests — `AsyncGeoTIFFReader` is the better\n",
-    "shape: same metadata surface as `RasterioReader`, but reads are coroutines\n",
-    "you can fan out with `asyncio.gather`.\n",
-    "\n",
-    "The two protocols are different (XYZ tiles ≠ COG windows), so this is\n",
-    "**not a 1:1 swap on the same input**. The cell below demonstrates the\n",
-    "equivalent shape against a real public COG — a Sentinel-2 L2A scene from\n",
-    "[Element 84's `sentinel-cogs` bucket](https://registry.opendata.aws/sentinel-2-l2a-cogs/)\n",
-    "(anonymously readable on AWS).\n",
-    "\n",
-    "Needs: `pip install georeader-spaceml[async] obstore`\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "d1d60b7b",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-05-14T16:12:00.718507Z",
-     "iopub.status.busy": "2026-05-14T16:12:00.718373Z",
-     "iopub.status.idle": "2026-05-14T16:12:01.977361Z",
-     "shell.execute_reply": "2026-05-14T16:12:01.977055Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "CRS:       EPSG:32630\n",
-      "shape:     (1, 10980, 10980)\n",
-      "dtype:     uint16\n",
-      "overviews: 4\n"
-     ]
-    }
-   ],
-   "source": [
-    "import asyncio\n",
-    "\n",
-    "import rasterio.windows\n",
-    "from obstore.store import S3Store\n",
-    "\n",
-    "from georeader.async_geotiff_reader import AsyncGeoTIFFReader\n",
-    "\n",
-    "# Element 84's sentinel-cogs bucket is anonymously readable on AWS.\n",
-    "store = S3Store(bucket=\"sentinel-cogs\", region=\"us-west-2\", skip_signature=True)\n",
-    "\n",
-    "# A stable public S2 L2A scene (UTM zone 30, MGRS tile T-UM, May 2022).\n",
-    "scene_path = (\n",
-    "    \"sentinel-s2-l2a-cogs/30/T/UM/2022/5/S2A_30TUM_20220506_0_L2A/B04.tif\"\n",
-    ")\n",
-    "\n",
-    "# open() fetches only the COG header (cheap; small range request).\n",
-    "reader = await AsyncGeoTIFFReader.open(scene_path, store=store)\n",
-    "print(f\"CRS:       {reader.crs}\")\n",
-    "print(f\"shape:     {reader.shape}\")\n",
-    "print(f\"dtype:     {reader.dtype}\")\n",
-    "print(f\"overviews: {len(reader._geotiff.overviews)}\")\n"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "id": "11a7509b",
-   "metadata": {
-    "execution": {
-     "iopub.execute_input": "2026-05-14T16:12:01.980638Z",
-     "iopub.status.busy": "2026-05-14T16:12:01.980519Z",
-     "iopub.status.idle": "2026-05-14T16:12:10.410172Z",
-     "shell.execute_reply": "2026-05-14T16:12:10.409769Z"
-    }
-   },
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Issued 16 concurrent reads from one process\n",
-      "All shapes correct: True\n"
-     ]
-    }
-   ],
-   "source": [
-    "# Fan out 16 concurrent window reads from one process / one event loop /\n",
-    "# one S3Store. Each await is a coroutine; asyncio.gather schedules them\n",
-    "# all at once, the Rust core coalesces adjacent tile fetches inside each call.\n",
-    "windows = [\n",
-    "    rasterio.windows.Window(col_off=5000 + (i % 4) * 256,\n",
-    "                            row_off=5000 + (i // 4) * 256,\n",
-    "                            width=256, height=256)\n",
-    "    for i in range(16)\n",
-    "]\n",
-    "\n",
-    "chips = await asyncio.gather(*[reader.read_from_window(w) for w in windows])\n",
-    "\n",
-    "print(f\"Issued {len(windows)} concurrent reads from one process\")\n",
-    "print(f\"All shapes correct: {all(c.values.shape == (1, 256, 256) for c in chips)}\")\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "id": "ced744f5",
-   "metadata": {},
-   "source": [
-    "See [`docs/advanced/async_geotiff_reader.ipynb`](../docs/advanced/async_geotiff_reader.ipynb)\n",
-    "for the full tutorial — the two-phase laziness model, overviews, the\n",
-    "post-load warp mini-solution, and the gotchas (TIFF/COG only, no warp,\n",
-    "not pickleable across processes).\n"
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "988d043a-cc09-47aa-a5e8-16142dfc618f",
diff --git a/tests/test_read_dataarray.py b/tests/test_read_dataarray.py
index 9c749e2..373b6de 100644
--- a/tests/test_read_dataarray.py
+++ b/tests/test_read_dataarray.py
@@ -444,8 +444,14 @@ def test_read_from_tile(reader_and_materialize, test_raster_path):
     raster is in EPSG:32738 South-East Africa; pick a low-zoom tile
     covering that area) and verifies that the returned chip has the
     expected web-mercator shape and CRS.
+
+    Async readers hit ``read.read_from_tile``'s reproject-internally
+    branch (no ``read_from_tile`` method on the reader → falls through
+    to ``read.read_reproject`` at line 1867 of read.py), so they go
+    through the pre-load pattern via ``_as_geotensor_for_reproject``.
     """
     reader, materialize = reader_and_materialize
+    reader = _as_geotensor_for_reproject(reader, materialize)
 
     # Compute a Z/X/Y tile covering the raster's geographic center.
     with rasterio.open(test_raster_path) as src:
@@ -461,11 +467,15 @@ def test_read_from_tile(reader_and_materialize, test_raster_path):
     xtile = int((lon + 180.0) / 360.0 * n)
     ytile = int((1.0 - math.log(math.tan(math.radians(lat)) + 1.0 / math.cos(math.radians(lat))) / math.pi) / 2.0 * n)
 
-    result = read.read_from_tile(reader, x=xtile, y=ytile, z=z)
-    chip_out = materialize(result)
+    chip_out = read.read_from_tile(reader, x=xtile, y=ytile, z=z)
 
-    if chip_out is None:
-        return
+    # The tile is computed from the raster's geographic centre — it MUST
+    # intersect. A None here means the read_from_tile intersection logic
+    # has regressed (used to silently early-exit before the fix).
+    assert chip_out is not None, (
+        f"read_from_tile returned None for an intersecting tile "
+        f"(z={z}, x={xtile}, y={ytile})"
+    )
 
     # Web-mercator tile reads return EPSG:3857 by default.
     assert str(chip_out.crs) == "EPSG:3857" or "3857" in str(chip_out.crs)