diff --git a/jupyter/README.md b/jupyter/README.md
index 08e3bdd8..5261b894 100644
--- a/jupyter/README.md
+++ b/jupyter/README.md
@@ -44,7 +44,8 @@ e.g. on a hub: `https://hub.example.org/user/<you>/gridlook/`.
 | `/gridlook/`                  | the static gridlook SPA                                                                                                                 |
 | `/gridlook/api/health`        | tiny JSON probe (`{"extension": "gridlook-jupyter", ...}`)                                                                              |
 | `/gridlook/s3/<bucket>/<key>` | streaming S3 proxy — GET/HEAD only, `Range` pass-through (206), no LIST                                                                 |
-| `/gridlook/hive/…`            | **reserved** for the phase-6 moczarr virtual-store endpoint (an `open_hive()` AOI served as one flat zarr store) — not implemented here |
+| `/gridlook/hive/open`         | open (or LRU-refresh) a **morton-hive virtual-store view** via moczarr — see below                                                      |
+| `/gridlook/hive/<view>/<key>` | serve one zarr object (metadata / whole chunk) of an open view                                                                          |
 
 ## Configuration
 
@@ -58,6 +59,12 @@ Via traitlets (`jupyter_server_config.py`, or `--GridlookProxy.…` on the comma
 c.GridlookProxy.allowed_buckets = ["my-zagg-outputs"]
 c.GridlookProxy.region = "us-west-2"          # optional; ambient AWS config otherwise
 c.GridlookProxy.static_dir = "/path/to/dist"  # optional; dev override for the SPA files
+
+# /gridlook/hive/ knobs (phase 6d; defaults shown)
+c.GridlookProxy.hive_max_views = 8            # LRU bound on materialized views
+c.GridlookProxy.hive_max_cells = 500_000      # per-view cell bound; 413 beyond
+c.GridlookProxy.hive_max_concurrent_builds = 2  # concurrent materializations; over-limit opens queue
+c.GridlookProxy.local_hive_store_roots = []   # allowed roots for local-path stores (dev only)
 ```
 
 Or environment variables (used only when the trait is not configured):
@@ -72,6 +79,58 @@ the standard hub setup. The proxy streams responses chunk-by-chunk and never buf
 objects; there are no presigned URLs, so nothing credential-shaped is ever exposed to the
 browser.
 
+## Morton-hive virtual store (`/gridlook/hive/`)
+
+Phase 6d of the viewer plan: a zagg **morton-hive** store is many leaf zarrs, but gridlook
+expects one zarr source — and post-englacial/zagg#314 stores are **morton-only**, so gridlook's
+existing HEALPix path (which consumes NESTED `cell_ids`) cannot read a leaf directly. The hive
+endpoint closes both gaps hub-side with [moczarr](https://github.com/espg/moczarr):
+`open_hive()` selects a product/AOI/window, **fabricates the exact NESTED `cell_ids`
+coordinate**, and the extension serves the result as **one flat zarr v3 store** the browser's
+unmodified zarrita reads.
+
+```
+GET /gridlook/hive/open?store=<url>[&product=<name>][&aoi=<decimal,csv>][&window=<label>]
+  -> {"view": "<id>", "url": ".../gridlook/hive/<id>", "cells": N, "cell_order": K, "cached": false}
+GET /gridlook/hive/<view>/<zarr-key>      # zarr.json documents and whole chunks
+```
+
+- `store` — hive store root: `s3://bucket/prefix` (bucket must be allowlisted, same posture as
+  the S3 proxy) or a local path whose realpath is contained in one of
+  `GridlookProxy.local_hive_store_roots` (empty by default — local stores disabled; dev/tests).
+- `product` — named product root under a multi-product store (zagg D19).
+- `aoi` — comma-separated morton decimals (mixed orders fine); omit for the whole store.
+- `window` — window label on a time-windowed (`morton-hive/2`) store.
+
+Views are **materialized on open** into an in-memory zarr store and held in a per-server LRU
+cache: `GridlookProxy.hive_max_views` (default 8) bounds the cache, and
+`GridlookProxy.hive_max_cells` (default 500 000) bounds a single view — an over-size selection
+gets a 413 telling you to narrow the AOI. Re-opening the same selection refreshes the existing
+view; evicted view URLs 404 until re-opened. Materialize-on-open keeps the serve path free of
+zarr chunk/codec arithmetic; a streaming/virtual encoding is the future optimization if views
+outgrow memory.
+
+The served attrs carry a **pre-6c compatibility shim**: gridlook's grid detector currently
+accepts only `dggs.name == "healpix"`, so the view advertises the healpix-shaped block with
+`coordinate: "cell_ids"` + `refinement_level` — the fabricated NESTED ids are plain HEALPix
+NESTED indices, exactly what the existing sparse-HEALPix render path consumes. When phase 6c
+teaches the detector the morton convention entry, the shim goes away.
+
+### CryoCloud MVP recipe: render a hive store
+
+```bash
+# 1. install the extension wheel plus the hive extra (moczarr; git source until PyPI)
+pip install gridlook_jupyter-<version>-py3-none-any.whl "gridlook-jupyter[hive]"
+# 2. allowlist the bucket holding the store (or use env GRIDLOOK_ALLOWED_BUCKETS)
+#    e.g. in jupyter_server_config.py: c.GridlookProxy.allowed_buckets = ["my-zagg-outputs"]
+#    ...then restart your server so the extension picks it up.
+```
+
+3. Open a view (in a notebook, `requests.get(...)`, or just a browser tab):
+   `https://<hub>/user/<you>/gridlook/hive/open?store=s3://my-zagg-outputs/store-root&aoi=4331422`
+4. Copy the returned `url`, open the app at `https://<hub>/user/<you>/gridlook/`, and paste the
+   view URL as the dataset source. The view renders through the existing HEALPix path.
+
 ## `s3://` inputs in the app
 
 When the SPA is served under `/gridlook/` (it detects this by probing `api/health`), pasting an
@@ -93,3 +152,8 @@ jupyter server --GridlookProxy.static_dir="$(pwd)/../dist" --GridlookProxy.allow
 
 Tests exercise the proxy against an obstore `LocalStore` via the `GridlookProxy.store_factory`
 seam — no real S3 needed.
+
+The hive tests run against moczarr's committed SERC fixture and need moczarr importable from a
+**repo checkout** (so the fixture sits next to the package): `uv pip install -e
+/path/to/moczarr` (or set `GRIDLOOK_MOCZARR_TESTDATA` to a checkout's `tests/data`). Without
+moczarr the hive suite skips.
diff --git a/jupyter/gridlook_jupyter/config.py b/jupyter/gridlook_jupyter/config.py
index 414d4598..f6def4b1 100644
--- a/jupyter/gridlook_jupyter/config.py
+++ b/jupyter/gridlook_jupyter/config.py
@@ -3,7 +3,7 @@
 import os
 from pathlib import Path
 
-from traitlets import List, Unicode, default
+from traitlets import Int, List, Unicode, default
 from traitlets.config import Configurable
 
 #: Bounded per-process cache of bucket -> store (buckets come from the allowlist,
@@ -47,6 +47,54 @@ class GridlookProxy(Configurable):
         ),
     ).tag(config=True)
 
+    local_hive_store_roots = List(
+        Unicode(),
+        help=(
+            "Root directories under which /gridlook/hive/open may open local "
+            "filesystem hive stores (development/tests). Empty (the default) "
+            "disables local stores entirely; a requested path is accepted only "
+            "when its realpath is contained in one of these (also realpath'd) "
+            "roots, so 'dev' can't become whole-filesystem reach. s3:// stores "
+            "are always gated by allowed_buckets instead. Env fallback: "
+            "GRIDLOOK_LOCAL_HIVE_STORE_ROOTS (comma-separated)."
+        ),
+    ).tag(config=True)
+
+    hive_max_views = Int(
+        8,
+        help=(
+            "Maximum materialized hive views held per server process; opening "
+            "beyond it evicts the least-recently-used view (its /gridlook/hive/ "
+            "URLs then 404 until re-opened)."
+        ),
+    ).tag(config=True)
+
+    hive_max_cells = Int(
+        500_000,
+        help=(
+            "Maximum cells a single hive view may materialize; /gridlook/hive/open "
+            "returns 413 beyond it. Views are held in memory (~100 B/cell at "
+            "typical zagg variable counts), so hive_max_views * hive_max_cells "
+            "bounds the RESIDENT cache footprint."
+        ),
+    ).tag(config=True)
+
+    hive_max_concurrent_builds = Int(
+        2,
+        help=(
+            "Maximum hive views materialized concurrently. Each in-flight open "
+            "holds its xarray dataset plus a MemoryStore copy transiently, ON TOP "
+            "of the resident cache, so a burst of opens can exceed the resident "
+            "bound; this caps that transient peak. Over-limit opens QUEUE (they "
+            "wait, they are not rejected)."
+        ),
+    ).tag(config=True)
+
+    @default("local_hive_store_roots")
+    def _default_local_hive_store_roots(self):
+        env = os.environ.get("GRIDLOOK_LOCAL_HIVE_STORE_ROOTS", "")
+        return [r.strip() for r in env.split(",") if r.strip()]
+
     @default("allowed_buckets")
     def _default_allowed_buckets(self):
         env = os.environ.get("GRIDLOOK_ALLOWED_BUCKETS", "")
diff --git a/jupyter/gridlook_jupyter/extension.py b/jupyter/gridlook_jupyter/extension.py
index a8a2ea3f..e53e2295 100644
--- a/jupyter/gridlook_jupyter/extension.py
+++ b/jupyter/gridlook_jupyter/extension.py
@@ -9,6 +9,7 @@
 
 from .config import GridlookProxy
 from .handlers import HealthHandler, S3ProxyHandler
+from .hive import HiveOpenHandler, HiveViewCache, HiveViewHandler
 
 
 def load_extension(serverapp):
@@ -26,9 +27,11 @@ def load_extension(serverapp):
     handlers = [
         (escaped + r"/api/health", HealthHandler),
         (escaped + r"/s3/([^/]+)/(.+)", S3ProxyHandler),
-        # /gridlook/hive/... is RESERVED: phase 6 mounts the moczarr virtual-store
-        # endpoint there (an open_hive() AOI served as one flat zarr store).
-        # Do not claim that namespace with other routes.
+        # Phase 6d: the moczarr virtual store on the namespace phase 4 reserved —
+        # an open_hive() product/AOI/window selection served as ONE flat zarr
+        # store (fabricated NESTED cell_ids included; see hive.py).
+        (escaped + r"/hive/open", HiveOpenHandler),
+        (escaped + r"/hive/([0-9a-f]{16})/(.+)", HiveViewHandler),
         (escaped + r"$", web.RedirectHandler, {"url": base + "/"}),
         (
             escaped + r"/(.*)",
@@ -37,6 +40,7 @@ def load_extension(serverapp):
         ),
     ]
     serverapp.web_app.settings["gridlook_proxy"] = proxy
+    serverapp.web_app.settings["gridlook_hive_views"] = HiveViewCache(proxy)
     serverapp.web_app.add_handlers(".*$", handlers)
     serverapp.log.info(
         "gridlook-jupyter loaded: app at %s/, proxy %s",
diff --git a/jupyter/gridlook_jupyter/handlers.py b/jupyter/gridlook_jupyter/handlers.py
index afc1e7e3..9e3f4626 100644
--- a/jupyter/gridlook_jupyter/handlers.py
+++ b/jupyter/gridlook_jupyter/handlers.py
@@ -77,10 +77,8 @@ async def get(self):
         )
 
 
-class S3ProxyHandler(JupyterHandler):
-    """Streaming byte-range proxy: GET/HEAD only, no LIST, hub-side credentials only."""
-
-    SUPPORTED_METHODS = ("GET", "HEAD")
+class PlainTextErrorMixin:
+    """Surface HTTPError log messages as plain-text bodies (pointed, curl-readable)."""
 
     def write_error(self, status_code, **kwargs):
         exc = kwargs.get("exc_info", (None, None, None))[1]
@@ -90,6 +88,12 @@ def write_error(self, status_code, **kwargs):
         self.set_header("Content-Type", "text/plain; charset=utf-8")
         self.finish(message or f"error {status_code}")
 
+
+class S3ProxyHandler(PlainTextErrorMixin, JupyterHandler):
+    """Streaming byte-range proxy: GET/HEAD only, no LIST, hub-side credentials only."""
+
+    SUPPORTED_METHODS = ("GET", "HEAD")
+
     def _store_for(self, bucket: str):
         proxy: GridlookProxy = self.settings["gridlook_proxy"]
         if not proxy.enabled:
diff --git a/jupyter/gridlook_jupyter/hive.py b/jupyter/gridlook_jupyter/hive.py
new file mode 100644
index 00000000..88277b5e
--- /dev/null
+++ b/jupyter/gridlook_jupyter/hive.py
@@ -0,0 +1,489 @@
+"""``/gridlook/hive/``: moczarr-backed virtual store — one flat zarr per ``open_hive()`` view.
+
+Phase 6d of the viewer plan (espg/gridlook#1): the hub-side answer to "a hive
+store is many leaves, but gridlook expects ONE zarr source". ``GET
+/gridlook/hive/open`` runs moczarr's ``open_hive()`` (product/AOI/window
+selection, fabricated NESTED ``cell_ids`` — post-englacial/zagg#314 stores are
+morton-only, so the fabrication is what makes them renderable at all) and
+MATERIALIZES the result into an in-memory zarr v3 store; ``GET
+/gridlook/hive/<view-id>/<key>`` then serves that store's objects (metadata and
+whole chunks — no Range support needed) to zarrita in the browser.
+
+Materialize-on-open, deliberately: views are AOI-scale and bounded
+(``GridlookProxy.hive_max_cells``, 413 beyond), materializing keeps this module
+free of zarr chunk/codec arithmetic (xarray writes the store; we serve opaque
+objects), and every subsequent request is a cache lookup. A streaming/virtual
+encoding — computing zarr objects on demand from the open dataset — is the
+future optimization if views ever outgrow memory; the URL contract here would
+not change.
+
+moczarr (and its xarray/zarr stack) is an extras-gated dependency
+(``gridlook-jupyter[hive]``); everything module-level here imports without it.
+"""
+
+import asyncio
+import functools
+import hashlib
+import json
+import os
+import re
+from collections import OrderedDict
+from dataclasses import dataclass, field
+from typing import Any
+
+from jupyter_server.base.handlers import JupyterHandler
+from jupyter_server.utils import url_path_join
+from tornado import web
+from tornado.ioloop import IOLoop
+
+from .config import GridlookProxy
+from .handlers import PlainTextErrorMixin
+
+#: hex digest prefix length for view ids (deterministic per request tuple).
+_VIEW_ID_HEX = 16
+
+#: Product names are single path segments under the store root (zagg D19 named
+#: product roots): no separators, no leading dot — nothing traversal-shaped.
+_PRODUCT_RE = re.compile(r"[A-Za-z0-9][A-Za-z0-9._-]*")
+
+#: AOI tokens are morton decimals (mortie spec §2; negative for southern base
+#: cells). The terminal-``p`` point form never names an area cover.
+_AOI_TOKEN_RE = re.compile(r"-?\d+")
+
+#: Highest HEALPix order whose NESTED ids stay below ``2**53`` and so survive
+#: as float64-exact JS Numbers in the browser (mirrors
+#: ``moczarr.fabricate.FLOAT64_EXACT_MAX_ORDER``). The frontend does all cell
+#: math (``nside = 2**refinement_level``, ``12*nside*nside``) in JS doubles, so
+#: anything above this renders wrong at HTTP 200.
+_FLOAT64_EXACT_MAX_ORDER = 24
+
+
+#: Per-event-loop build semaphores, keyed by loop and rebuilt when the
+#: configured limit changes. Bounds concurrent ``build_view`` offloads so a
+#: burst of opens can't hold N×(dataset + store) transiently on top of the
+#: resident cache; over-limit opens wait on ``acquire`` (they queue, no 503).
+#: Keyed by loop (not a bare module global) so it stays sound across the fresh
+#: event loop each test — and each real server process — runs under.
+_BUILD_SEMAPHORES: dict[asyncio.AbstractEventLoop, tuple[int, asyncio.Semaphore]] = {}
+
+
+def _build_semaphore(limit: int) -> asyncio.Semaphore:
+    """The build semaphore for the running loop, sized to *limit* (min 1)."""
+    loop = asyncio.get_running_loop()
+    limit = max(1, limit)
+    cached = _BUILD_SEMAPHORES.get(loop)
+    if cached is None or cached[0] != limit:
+        sem = asyncio.Semaphore(limit)
+        _BUILD_SEMAPHORES[loop] = (limit, sem)
+        return sem
+    return cached[1]
+
+
+class ViewTooLargeError(Exception):
+    """Raised when an open would materialize more cells than ``hive_max_cells``."""
+
+    def __init__(self, cells: int):
+        self.cells = cells
+
+
+class ViewNotFloat64ExactError(Exception):
+    """Raised when a view's fabricated NESTED ids exceed the float64-exact range.
+
+    The browser holds cell ids as float64 Numbers, so an AREA store above
+    ``_FLOAT64_EXACT_MAX_ORDER`` (order 24) would render silently wrong — reject
+    at open rather than serve it. POINT-kind words clip to order 24 in
+    fabrication and are fine (see :func:`_served_refinement_level`).
+    """
+
+    def __init__(self, order: int):
+        self.order = order
+
+
+@dataclass
+class HiveView:
+    """One materialized view: an in-memory zarr store plus its provenance."""
+
+    store: Any  # zarr.storage.MemoryStore
+    cells: int
+    cell_order: int
+    store_url: str
+    product: str | None
+    window: str | None
+    aoi: tuple[str, ...] | None = field(default=None)
+
+
+class HiveViewCache:
+    """LRU-bounded ``view-id -> HiveView`` map, one per server process.
+
+    View ids are deterministic over the request tuple, so re-opening the same
+    selection refreshes (LRU-bumps) the existing view instead of duplicating
+    it; serving a view's objects bumps it too, so actively rendered views
+    survive. Views are re-materialized only after eviction.
+    """
+
+    def __init__(self, proxy: GridlookProxy):
+        self._proxy = proxy
+        self._views: OrderedDict[str, HiveView] = OrderedDict()
+
+    @staticmethod
+    def view_id(
+        store_url: str, product: str | None, window: str | None, aoi: tuple[str, ...] | None
+    ) -> str:
+        # Canonicalize so selections that name the SAME data collapse to one id
+        # (one materialization, one LRU slot): strip the store's trailing slash
+        # (build_view rstrips it for the data path anyway), normalize empty
+        # params to absent, and sort+dedupe the aoi tokens (order and repeats
+        # don't change the cover).
+        aoi_canon = sorted({int(t) for t in aoi}) if aoi else None
+        payload = json.dumps(
+            [store_url.rstrip("/"), product or None, window or None, aoi_canon],
+            separators=(",", ":"),
+        )
+        return hashlib.sha256(payload.encode()).hexdigest()[:_VIEW_ID_HEX]
+
+    def get(self, view_id: str) -> HiveView | None:
+        view = self._views.get(view_id)
+        if view is not None:
+            self._views.move_to_end(view_id)
+        return view
+
+    def put(self, view_id: str, view: HiveView) -> None:
+        self._views[view_id] = view
+        self._views.move_to_end(view_id)
+        while len(self._views) > max(1, self._proxy.hive_max_views):
+            self._views.popitem(last=False)
+
+
+#: The zarr-conventions envelope entry for the dggs convention, added only when
+#: a store somehow lacks one (gridlook's detector keys on the envelope's presence).
+_DGGS_CONVENTION_ENTRY = {
+    "schema_url": "https://raw.githubusercontent.com/zarr-conventions/dggs/refs/tags/v1/schema.json",
+    "spec_url": "https://github.com/zarr-conventions/dggs/blob/v1/README.md",
+    "uuid": "7b255807-140c-42ca-97f6-7a1cfecdbc38",
+    "name": "dggs",
+    "description": "Discrete Global Grid Systems convention for zarr",
+}
+
+
+def _served_refinement_level(cell_ids, morton_words, cell_order: int) -> int:
+    """The HEALPix order the *served* NESTED ids actually sit at.
+
+    ``cell_order`` (the manifest's) is the order of the stored WORDS, not
+    always the order of the fabricated ids: ``fabricate_cell_ids`` clips
+    POINT-kind words (spec §1/§4) to :data:`_FLOAT64_EXACT_MAX_ORDER`, so a
+    point store's served ids sit at 24 even though its manifest declares order
+    29. Deriving ``refinement_level`` from the served ids (not the manifest)
+    makes point stores render at the right scale instead of at a mismatched
+    ``nside = 2**29``. AREA words never clip — an area store above order 24
+    would serve ids the browser cannot hold as float64 (``2**53``), so we
+    reject it (:class:`ViewNotFloat64ExactError`) rather than render it wrong.
+    """
+    import numpy as np
+    from moczarr.convention import is_point_word
+
+    words = np.asarray(morton_words, dtype=np.uint64).ravel()
+    is_point = bool(np.asarray(is_point_word(words)).any()) if words.size else False
+    order = _FLOAT64_EXACT_MAX_ORDER if is_point else int(cell_order)
+    ids = np.asarray(cell_ids, dtype=np.uint64).ravel()
+    max_id = int(ids.max()) if ids.size else 0
+    # Honest float64 guard on the served bytes: an area store above order 24, or
+    # a mixed store whose real order-29 areas ride past the point clip, trips this.
+    if order > _FLOAT64_EXACT_MAX_ORDER or max_id >= 12 * 4**_FLOAT64_EXACT_MAX_ORDER:
+        raise ViewNotFloat64ExactError(int(cell_order))
+    return order
+
+
+def _shim_dggs_attrs(ds, refinement_level: int) -> None:
+    """Rewrite the served ``dggs`` attrs to the healpix-shaped block gridlook reads TODAY.
+
+    PRE-6C COMPATIBILITY SHIM. A morton-only hive's stored convention block is
+    ``{name: "morton", coordinate: "morton"}`` (mortie spec §5); gridlook's
+    ``gridTypeDetector.ts`` currently rejects any ``dggs.name != "healpix"``,
+    and ``Healpix.vue`` reads ``refinement_level`` (→ nside) plus
+    ``coordinate`` (→ the cell-id coordinate). The fabricated NESTED
+    ``cell_ids`` ARE plain HEALPix NESTED indices at ``refinement_level``, so
+    advertising ``{name: "healpix", coordinate: "cell_ids"}`` feeds the
+    existing sparse limited-area HEALPix path bit-for-bit what it already
+    consumes — no frontend change needed. ``refinement_level`` is the order the
+    served ids actually sit at (:func:`_served_refinement_level`), NOT the raw
+    manifest ``cell_order`` (which is the point-store trap). Phase 6c teaches
+    the detector the morton convention entry natively; when it lands, this shim
+    can serve the stored block unmodified.
+    """
+    from moczarr.convention import MORTON_CONVENTION_UUID
+
+    source_dggs = ds.attrs.get("dggs")
+    dggs = dict(source_dggs or {})
+    dggs.update(
+        {"name": "healpix", "refinement_level": int(refinement_level), "coordinate": "cell_ids"}
+    )
+    dggs.setdefault("spatial_dimension", "cells")
+    ds.attrs["dggs"] = dggs
+    # Serve ONE coherent envelope: the block above now says healpix, so the
+    # stored morton-dggs convention entry (which claims a packed-morton
+    # coordinate) contradicts it — drop it, keeping the generic dggs registry
+    # entry the detector reads. The store's own block is preserved verbatim
+    # under a private attr for provenance (nothing is lost, just re-flavored).
+    if source_dggs is not None:
+        ds.attrs["_gridlook_source_dggs"] = source_dggs
+    conventions = ds.attrs.get("zarr_conventions")
+    kept = (
+        [
+            e
+            for e in conventions
+            if not (
+                isinstance(e, dict)
+                and (
+                    e.get("name") in ("morton-dggs", "morton")
+                    or e.get("uuid") == MORTON_CONVENTION_UUID
+                )
+            )
+        ]
+        if isinstance(conventions, list)
+        else []
+    )
+    if not any(isinstance(e, dict) and e.get("name") == "dggs" for e in kept):
+        kept.append(_DGGS_CONVENTION_ENTRY)
+    ds.attrs["zarr_conventions"] = kept
+
+
+def build_view(
+    root: str,
+    *,
+    store_url: str,
+    product: str | None,
+    aoi: tuple[str, ...] | None,
+    window: str | None,
+    max_cells: int,
+) -> HiveView:
+    """Open a hive selection and materialize it as an in-memory zarr store.
+
+    Synchronous and potentially slow (S3 GETs, concat) — the handler runs it
+    on the executor, off the event loop.
+    """
+    import zarr
+    from moczarr import open_hive
+
+    ds = open_hive(
+        root,
+        aoi=list(aoi) if aoi else None,
+        window=window,
+        # Load-bearing: post-zagg#314 stores carry only the packed-u64 morton
+        # coordinate; "auto" fabricates the exact NESTED cell_ids view the
+        # browser-side HEALPix path consumes (and keeps stored bytes on any
+        # remaining dual-written store).
+        fabricate_cell_ids="auto",
+    )
+    dim = ds["morton"].dims[0] if "morton" in ds.coords else "cells"
+    cells = int(ds.sizes.get(dim, 0))
+    if cells > max_cells:
+        raise ViewTooLargeError(cells)
+    cell_order = int(ds.attrs["morton_hive"]["cell_order"])
+    # Derive from the SERVED ids (point words clip to order 24), and reject
+    # area stores whose ids the browser can't hold as float64 — the warning
+    # moczarr emits for those is swallowed on the executor thread.
+    refinement_level = _served_refinement_level(
+        ds["cell_ids"].values, ds["morton"].values, cell_order
+    )
+    _shim_dggs_attrs(ds, refinement_level)
+    mem = zarr.storage.MemoryStore()
+    # No compression: objects are served whole over hub-local HTTP, views are
+    # session-scoped, and codec-free chunks keep the served bytes trivially
+    # predictable (the tests compare them raw).
+    encoding = {name: {"compressors": None} for name in list(ds.data_vars) + list(ds.coords)}
+    ds.to_zarr(mem, mode="w", consolidated=False, zarr_format=3, encoding=encoding)
+    return HiveView(
+        store=mem,
+        cells=cells,
+        cell_order=int(ds.attrs["morton_hive"]["cell_order"]),
+        store_url=store_url,
+        product=product,
+        window=window,
+        aoi=aoi,
+    )
+
+
+def _parse_aoi(raw: str | None) -> tuple[str, ...] | None:
+    if raw is None:
+        return None
+    tokens = tuple(t.strip() for t in raw.split(",") if t.strip())
+    if not tokens:
+        raise web.HTTPError(400, "aoi= is empty — expected comma-separated morton decimals")
+    for token in tokens:
+        if not _AOI_TOKEN_RE.fullmatch(token):
+            raise web.HTTPError(400, f"aoi token {token!r} is not a morton decimal")
+    return tokens
+
+
+def _authorize_store_root(proxy: GridlookProxy, store_url: str, product: str | None) -> str:
+    """Allowlist gate (same posture as the S3 proxy) and product-root resolution."""
+    if product is not None and not _PRODUCT_RE.fullmatch(product):
+        raise web.HTTPError(400, f"invalid product name: {product!r}")
+    if store_url.startswith("s3://"):
+        bucket = store_url[len("s3://") :].split("/", 1)[0]
+        if not bucket:
+            raise web.HTTPError(400, f"invalid store URL: {store_url!r}")
+        if not proxy.enabled:
+            raise web.HTTPError(
+                403,
+                "gridlook hive endpoint is disabled for S3: no allowed buckets are "
+                "configured. Set GridlookProxy.allowed_buckets (or GRIDLOOK_ALLOWED_BUCKETS).",
+            )
+        if bucket not in proxy.allowed_buckets:
+            raise web.HTTPError(
+                403,
+                f"bucket '{bucket}' is not in the gridlook proxy allowlist "
+                f"(GridlookProxy.allowed_buckets)",
+            )
+    elif "://" in store_url:
+        raise web.HTTPError(
+            403, f"unsupported store scheme in {store_url!r}: use s3://… or a local path"
+        )
+    elif not _local_path_allowed(proxy, store_url):
+        # Uniform body regardless of whether the path exists / is a file /
+        # is a directory: an authenticated user must not learn the on-box
+        # filesystem layout by probing store= (existence/type oracle).
+        raise web.HTTPError(
+            403,
+            "local-path hive store is not within an allowed root — set "
+            "GridlookProxy.local_hive_store_roots (development only)",
+        )
+    root = store_url.rstrip("/")
+    return f"{root}/{product}" if product else root
+
+
+def _local_path_allowed(proxy: GridlookProxy, store_url: str) -> bool:
+    """Whether *store_url* resolves inside one of the configured local roots.
+
+    Containment is checked on ``realpath`` (symlinks resolved) so a path that
+    is textually under a root but links outside it is rejected. Empty roots
+    (the default) disable local stores entirely.
+    """
+    roots = proxy.local_hive_store_roots
+    if not roots:
+        return False
+    real = os.path.realpath(store_url)
+    for root in roots:
+        rroot = os.path.realpath(root)
+        if real == rroot or real.startswith(rroot + os.sep):
+            return True
+    return False
+
+
+class HiveOpenHandler(PlainTextErrorMixin, JupyterHandler):
+    """``GET /gridlook/hive/open?store=…[&product=…][&aoi=…][&window=…]``.
+
+    Creates (or LRU-refreshes) a view and returns its id plus the entry URL to
+    paste into gridlook as a zarr dataset source.
+    """
+
+    @web.authenticated
+    async def get(self):
+        proxy: GridlookProxy = self.settings["gridlook_proxy"]
+        cache: HiveViewCache = self.settings["gridlook_hive_views"]
+        store_url = self.get_query_argument("store", None)
+        if not store_url:
+            raise web.HTTPError(
+                400, "missing required query parameter: store=<hive store root URL or path>"
+            )
+        product = self.get_query_argument("product", None) or None
+        window = self.get_query_argument("window", None) or None
+        aoi = _parse_aoi(self.get_query_argument("aoi", None) or None)
+        root = _authorize_store_root(proxy, store_url, product)
+        try:
+            import moczarr  # noqa: F401
+        except ImportError as e:
+            raise web.HTTPError(
+                500,
+                "the /gridlook/hive/ endpoints need moczarr — install gridlook-jupyter[hive]",
+            ) from e
+
+        view_id = cache.view_id(store_url, product, window, aoi)
+        view = cache.get(view_id)
+        cached = view is not None
+        if view is None:
+            build = functools.partial(
+                build_view,
+                root,
+                store_url=store_url,
+                product=product,
+                aoi=aoi,
+                window=window,
+                max_cells=proxy.hive_max_cells,
+            )
+            try:
+                # Cap concurrent materializations (each holds ds + store copy
+                # transiently); over-limit opens queue on acquire.
+                async with _build_semaphore(proxy.hive_max_concurrent_builds):
+                    view = await IOLoop.current().run_in_executor(None, build)
+            except ViewTooLargeError as e:
+                raise web.HTTPError(
+                    413,
+                    f"hive view would materialize {e.cells} cells, over the "
+                    f"{proxy.hive_max_cells}-cell limit — narrow the aoi= or window= "
+                    f"selection (or raise GridlookProxy.hive_max_cells)",
+                ) from e
+            except ViewNotFloat64ExactError as e:
+                raise web.HTTPError(
+                    422,
+                    f"hive store cell_order {e.order} exceeds order "
+                    f"{_FLOAT64_EXACT_MAX_ORDER}: its NESTED cell_ids are above the "
+                    f"float64-exact integer range (2**53) that the browser holds cell "
+                    f"ids in, so it cannot be rendered (point-kind stores clip to order "
+                    f"{_FLOAT64_EXACT_MAX_ORDER} and are fine; area stores do not)",
+                ) from e
+            except FileNotFoundError as e:
+                raise web.HTTPError(404, f"no hive store at {store_url!r}: {e}") from e
+            except ValueError as e:
+                # moczarr's NoCoverageError (nothing committed anywhere) is a
+                # ValueError subclass: the store exists but has nothing to
+                # serve — 404, not a bad request.
+                status = 404 if type(e).__name__ == "NoCoverageError" else 400
+                raise web.HTTPError(status, f"cannot open {store_url!r}: {e}") from e
+            cache.put(view_id, view)
+
+        self.set_header("Content-Type", "application/json")
+        self.finish(
+            json.dumps(
+                {
+                    "view": view_id,
+                    "url": url_path_join(self.base_url, "gridlook", "hive", view_id),
+                    "cells": view.cells,
+                    "cell_order": view.cell_order,
+                    "cached": cached,
+                }
+            )
+        )
+
+
+class HiveViewHandler(PlainTextErrorMixin, JupyterHandler):
+    """``GET /gridlook/hive/<view-id>/<key>``: serve one zarr object of a view.
+
+    Objects are metadata documents and whole (small) chunks — no Range
+    support, mirroring how zarrita fetches them.
+    """
+
+    @web.authenticated
+    async def get(self, view_id: str, key: str):
+        cache: HiveViewCache = self.settings["gridlook_hive_views"]
+        view = cache.get(view_id)
+        if view is None:
+            raise web.HTTPError(
+                404,
+                f"no hive view '{view_id}' (never opened, or evicted from the LRU "
+                f"cache) — (re)open it via /gridlook/hive/open",
+            )
+        from zarr.core.buffer import default_buffer_prototype
+
+        buf = await view.store.get(key, prototype=default_buffer_prototype())
+        if buf is None:
+            raise web.HTTPError(404, f"no object '{key}' in hive view '{view_id}'")
+        data = buf.to_bytes()
+        self.set_header(
+            "Content-Type",
+            "application/json" if key.endswith(".json") else "application/octet-stream",
+        )
+        self.set_header("Content-Length", str(len(data)))
+        # View URLs die on eviction; keep intermediaries from pinning stale objects.
+        self.set_header("Cache-Control", "no-store")
+        self.finish(data)
diff --git a/jupyter/pyproject.toml b/jupyter/pyproject.toml
index 56b1f6e3..1b75cad6 100644
--- a/jupyter/pyproject.toml
+++ b/jupyter/pyproject.toml
@@ -17,11 +17,22 @@ dependencies = [
 ]
 
 [project.optional-dependencies]
+# The /gridlook/hive/ virtual store (phase 6d): moczarr opens morton-hive
+# stores hub-side and fabricates the NESTED cell_ids view. Not on PyPI yet —
+# the git source is the interim shape (tests run against a local checkout).
+hive = [
+    "moczarr @ git+https://github.com/espg/moczarr",
+]
 test = [
     "pytest>=8",
     "pytest-jupyter[server]>=0.10",
 ]
 
+[tool.hatch.metadata]
+# The [hive] extra's moczarr pin is a git direct reference until moczarr
+# publishes to PyPI; drop this (and the pin's @ git+…) when it does.
+allow-direct-references = true
+
 [tool.hatch.build.targets.wheel]
 packages = ["gridlook_jupyter"]
 # The static SPA is copied in by the build hook and is gitignored; `artifacts`
diff --git a/jupyter/tests/conftest.py b/jupyter/tests/conftest.py
index fad469de..e1d4dd57 100644
--- a/jupyter/tests/conftest.py
+++ b/jupyter/tests/conftest.py
@@ -27,12 +27,19 @@ def allowed_buckets():
 
 
 @pytest.fixture
-def jp_server_config(static_root, allowed_buckets):
+def hive_config():
+    """GridlookProxy hive traits; override per test module/class (roots, LRU, size)."""
+    return {"local_hive_store_roots": []}
+
+
+@pytest.fixture
+def jp_server_config(static_root, allowed_buckets, hive_config):
     return {
         "ServerApp": {"jpserver_extensions": {"gridlook_jupyter": True}},
         "GridlookProxy": {
             "allowed_buckets": allowed_buckets,
             "static_dir": str(static_root),
+            **hive_config,
         },
     }
 
diff --git a/jupyter/tests/test_hive.py b/jupyter/tests/test_hive.py
new file mode 100644
index 00000000..15dfbffd
--- /dev/null
+++ b/jupyter/tests/test_hive.py
@@ -0,0 +1,357 @@
+"""``/gridlook/hive/`` virtual-store views against moczarr's committed SERC fixture.
+
+The fixture (``tests/data/serc_hive`` in the moczarr repo) is zagg-written and
+morton-only (post englacial/zagg#314), so every ``cell_ids`` assertion here
+exercises moczarr's NESTED fabrication — the load-bearing 6d piece. The suite
+needs moczarr importable from a repo checkout (e.g. ``uv pip install -e
+/path/to/moczarr``) so the fixture is reachable next to the package; a
+plain-``[test]`` environment skips it wholesale.
+"""
+
+import json
+import os
+from pathlib import Path
+
+import pytest
+from tornado.httpclient import HTTPClientError
+
+moczarr = pytest.importorskip("moczarr", reason="hive tests need gridlook-jupyter[hive]")
+np = pytest.importorskip("numpy")
+
+
+def _moczarr_testdata() -> Path:
+    env = os.environ.get("GRIDLOOK_MOCZARR_TESTDATA")
+    if env:
+        return Path(env)
+    # src layout: src/moczarr/__init__.py -> parents[2] is the repo root.
+    return Path(moczarr.__file__).resolve().parents[2] / "tests" / "data"
+
+
+TESTDATA = _moczarr_testdata()
+SERC = TESTDATA / "serc_hive"
+#: The stored cell_ids of the last dual-written SERC fixture (pre-zagg#314),
+#: whole-store concat order — moczarr's fabrication-parity golden.
+GOLDEN = TESTDATA / "serc_cell_ids_golden.npy"
+#: An order-6 stamped shard of the fixture (the SERC site itself).
+SERC_SHARD = "4331422"
+
+pytestmark = pytest.mark.skipif(
+    not (SERC / "morton_hive.json").exists(),
+    reason=f"moczarr SERC fixture not found at {SERC} (needs a moczarr repo checkout; "
+    "set GRIDLOOK_MOCZARR_TESTDATA to its tests/data)",
+)
+
+
+@pytest.fixture
+def hive_config():
+    """Configure TESTDATA as the allowed local root so the fixture is openable."""
+    return {"local_hive_store_roots": [str(TESTDATA)]}
+
+
+async def _open(jp_fetch, **params):
+    resp = await jp_fetch("gridlook", "hive", "open", params={"store": str(SERC), **params})
+    assert resp.code == 200
+    return json.loads(resp.body)
+
+
+async def _fetch_array(jp_fetch, view, name, dtype=None):
+    meta = json.loads((await jp_fetch("gridlook", "hive", view, f"{name}/zarr.json")).body)
+    # Uncompressed by design: the raw chunk bytes ARE the array.
+    assert [c["name"] for c in meta["codecs"]] == ["bytes"]
+    if dtype is None:
+        dtype = np.dtype(meta["data_type"]).newbyteorder("<")
+    chunk = await jp_fetch("gridlook", "hive", view, f"{name}/c/0")
+    assert chunk.headers["Content-Type"] == "application/octet-stream"
+    return np.frombuffer(chunk.body, dtype=dtype)
+
+
+async def test_open_returns_view_and_entry_url(jp_fetch):
+    out = await _open(jp_fetch)
+    assert set(out) >= {"view", "url", "cells", "cell_order", "cached"}
+    assert out["url"].endswith(f"/gridlook/hive/{out['view']}")
+    assert out["cells"] == len(np.load(GOLDEN))
+    assert out["cell_order"] == 8
+    assert out["cached"] is False
+
+
+async def test_reopen_same_selection_reuses_view(jp_fetch):
+    first = await _open(jp_fetch)
+    again = await _open(jp_fetch)
+    assert again["view"] == first["view"]
+    assert again["cached"] is True
+
+
+async def test_zarr_json_carries_healpix_shim_attrs(jp_fetch):
+    out = await _open(jp_fetch)
+    resp = await jp_fetch("gridlook", "hive", out["view"], "zarr.json")
+    assert resp.code == 200
+    assert resp.headers["Content-Type"] == "application/json"
+    attrs = json.loads(resp.body)["attributes"]
+    # Pre-6c compatibility shim: gridlook's detector accepts only
+    # dggs.name == "healpix" today; the served block points its existing
+    # sparse-HEALPix path at the fabricated NESTED cell_ids.
+    assert "zarr_conventions" in attrs
+    dggs = attrs["dggs"]
+    assert dggs["name"] == "healpix"
+    assert dggs["coordinate"] == "cell_ids"
+    assert dggs["refinement_level"] == 8
+    assert attrs["morton_hive"]["cell_order"] == 8
+
+
+async def test_zarr_conventions_single_coherent_block(jp_fetch):
+    out = await _open(jp_fetch)
+    resp = await jp_fetch("gridlook", "hive", out["view"], "zarr.json")
+    attrs = json.loads(resp.body)["attributes"]
+    conventions = attrs["zarr_conventions"]
+    names = [e.get("name") for e in conventions]
+    # The served envelope no longer claims the morton-dggs convention (it would
+    # contradict the healpix-flavored dggs block); exactly the generic dggs
+    # registry entry remains.
+    assert "morton-dggs" not in names
+    assert names.count("dggs") == 1
+    # Provenance: the store's own morton block is preserved verbatim.
+    assert attrs["_gridlook_source_dggs"]["name"] == "morton"
+    assert attrs["_gridlook_source_dggs"]["coordinate"] == "morton"
+
+
+#: Golden point/area order-29 packed words (moczarr test_convention, suffix bands
+#: §1) — a point word (suffix 48/61) clips to order 24 in fabrication.
+POINT_NORTH_WORD = 4733760060091642301  # suffix 61
+POINT_SOUTH_WORD = 13712984013617909360  # suffix 48
+
+
+class TestServedRefinementLevel:
+    """refinement_level comes from the SERVED ids' order, not the manifest cell_order."""
+
+    def test_area_store_uses_manifest_order(self):
+        from gridlook_jupyter.hive import _served_refinement_level
+
+        # Non-point words (low suffix bands) at order 8: served ids sit at 8.
+        words = np.array([8, 4108, 12], dtype=np.uint64)
+        ids = np.array([0, 1, 100], dtype=np.uint64)
+        assert _served_refinement_level(ids, words, cell_order=8) == 8
+
+    def test_point_store_clips_to_float64_ceiling(self):
+        from moczarr.convention import is_point_word
+        from moczarr.fabricate import fabricate_cell_ids
+
+        from gridlook_jupyter.hive import _served_refinement_level
+
+        words = np.array([POINT_NORTH_WORD, POINT_SOUTH_WORD], dtype=np.uint64)
+        assert bool(np.asarray(is_point_word(words)).all())
+        ids = fabricate_cell_ids(words)  # point words clip to order 24
+        # Manifest says order 29 (points are order-29 encoded); the served ids
+        # are at order 24, and THAT is what the shim must declare.
+        assert _served_refinement_level(ids, words, cell_order=29) == 24
+
+    def test_area_above_float64_ceiling_rejected(self):
+        from gridlook_jupyter.hive import ViewNotFloat64ExactError, _served_refinement_level
+
+        words = np.array([25], dtype=np.uint64)  # non-point (suffix 25)
+        ids = np.array([0, 1], dtype=np.uint64)
+        with pytest.raises(ViewNotFloat64ExactError):
+            _served_refinement_level(ids, words, cell_order=25)
+
+    def test_ids_beyond_float64_range_rejected(self):
+        from gridlook_jupyter.hive import ViewNotFloat64ExactError, _served_refinement_level
+
+        # Non-point words at a declared order 24, but an id past 12*4**24 (a
+        # mixed store whose real order-29 areas ride past the point clip).
+        words = np.array([24], dtype=np.uint64)
+        ids = np.array([0, 12 * 4**24], dtype=np.uint64)
+        with pytest.raises(ViewNotFloat64ExactError):
+            _served_refinement_level(ids, words, cell_order=24)
+
+
+class TestViewIdCanonicalization:
+    """Selections naming the same data hash to one view id (no LRU thrash)."""
+
+    def test_aoi_order_and_dupes_collapse(self):
+        from gridlook_jupyter.hive import HiveViewCache
+
+        base = HiveViewCache.view_id("s3://b/root", None, None, ("4331421", "4331422"))
+        reordered = HiveViewCache.view_id("s3://b/root", None, None, ("4331422", "4331421"))
+        duped = HiveViewCache.view_id("s3://b/root", None, None, ("4331421", "4331421", "4331422"))
+        assert base == reordered == duped
+
+    def test_trailing_slash_collapses(self):
+        from gridlook_jupyter.hive import HiveViewCache
+
+        assert HiveViewCache.view_id("s3://b/root", None, None, None) == HiveViewCache.view_id(
+            "s3://b/root/", None, None, None
+        )
+
+    def test_empty_params_equal_absent(self):
+        from gridlook_jupyter.hive import HiveViewCache
+
+        assert HiveViewCache.view_id("s3://b/root", "", "", None) == HiveViewCache.view_id(
+            "s3://b/root", None, None, None
+        )
+
+    def test_distinct_selections_differ(self):
+        from gridlook_jupyter.hive import HiveViewCache
+
+        a = HiveViewCache.view_id("s3://b/root", None, None, ("4331421",))
+        b = HiveViewCache.view_id("s3://b/root", None, None, ("4331422",))
+        assert a != b
+
+
+async def test_cell_ids_match_moczarr_fabrication_golden(jp_fetch):
+    out = await _open(jp_fetch)
+    ids = await _fetch_array(jp_fetch, out["view"], "cell_ids", "<u8")
+    # NESTED values byte-equal the golden (the last dual-written store's
+    # stored cell_ids): fabricate-at-serve loses nothing.
+    assert np.array_equal(ids, np.load(GOLDEN).astype(np.uint64))
+
+
+async def test_data_variable_chunk_served(jp_fetch):
+    out = await _open(jp_fetch)
+    counts = await _fetch_array(jp_fetch, out["view"], "count")
+    assert len(counts) == out["cells"]
+
+
+async def test_aoi_subsets_to_one_shard(jp_fetch):
+    out = await _open(jp_fetch, aoi=SERC_SHARD)
+    assert out["cells"] == 16  # 4^(cell_order 8 - shard_order 6)
+    words = await _fetch_array(jp_fetch, out["view"], "morton", "<u8")
+    ids = await _fetch_array(jp_fetch, out["view"], "cell_ids", "<u8")
+    from moczarr.fabricate import fabricate_cell_ids
+
+    assert np.array_equal(ids, fabricate_cell_ids(words.astype(np.uint64)))
+    golden = set(np.load(GOLDEN).astype(np.uint64).tolist())
+    assert set(ids.tolist()) < golden
+
+
+async def test_bad_aoi_400(jp_fetch):
+    with pytest.raises(HTTPClientError) as e:
+        await _open(jp_fetch, aoi="4331422,nope")
+    assert e.value.code == 400
+    assert b"morton decimal" in e.value.response.body
+
+
+async def test_window_on_unwindowed_store_400(jp_fetch):
+    with pytest.raises(HTTPClientError) as e:
+        await _open(jp_fetch, window="2019")
+    assert e.value.code == 400
+
+
+async def test_missing_store_param_400(jp_fetch):
+    with pytest.raises(HTTPClientError) as e:
+        await jp_fetch("gridlook", "hive", "open")
+    assert e.value.code == 400
+    assert b"store=" in e.value.response.body
+
+
+async def test_non_allowlisted_bucket_403(jp_fetch):
+    with pytest.raises(HTTPClientError) as e:
+        await jp_fetch("gridlook", "hive", "open", params={"store": "s3://sneaky-bucket/hive-root"})
+    assert e.value.code == 403
+    assert b"sneaky-bucket" in e.value.response.body
+    assert b"allowlist" in e.value.response.body
+
+
+async def test_unknown_view_404(jp_fetch):
+    with pytest.raises(HTTPClientError) as e:
+        await jp_fetch("gridlook", "hive", "0123456789abcdef", "zarr.json")
+    assert e.value.code == 404
+    assert b"/gridlook/hive/open" in e.value.response.body
+
+
+async def test_missing_object_404(jp_fetch):
+    out = await _open(jp_fetch)
+    with pytest.raises(HTTPClientError) as e:
+        await jp_fetch("gridlook", "hive", out["view"], "nope/zarr.json")
+    assert e.value.code == 404
+
+
+class TestLocalStoresDisabled:
+    @pytest.fixture
+    def hive_config(self):
+        return {"local_hive_store_roots": []}
+
+    async def test_local_path_403(self, jp_fetch):
+        with pytest.raises(HTTPClientError) as e:
+            await jp_fetch("gridlook", "hive", "open", params={"store": str(SERC)})
+        assert e.value.code == 403
+        assert b"local_hive_store_roots" in e.value.response.body
+
+
+class TestLocalStoreRootContainment:
+    """Only paths inside a configured root open; everything else is a uniform 403."""
+
+    @pytest.fixture
+    def hive_config(self):
+        # SERC's parent is allowed, but not the filesystem at large.
+        return {"local_hive_store_roots": [str(TESTDATA)]}
+
+    @pytest.mark.parametrize(
+        "outside",
+        [
+            "/etc/passwd",  # a file that exists
+            "/etc",  # a directory that exists (no manifest)
+            "/nonexistent/hive/store",  # a path that does not exist
+            str(TESTDATA.parent),  # the parent of the root (just above containment)
+        ],
+    )
+    async def test_outside_root_uniform_403(self, jp_fetch, outside):
+        with pytest.raises(HTTPClientError) as e:
+            await jp_fetch("gridlook", "hive", "open", params={"store": outside})
+        assert e.value.code == 403
+        # No existence/type distinction: identical body for file / dir / missing.
+        assert b"not within an allowed root" in e.value.response.body
+        assert b"local_hive_store_roots" in e.value.response.body
+
+    async def test_fixture_inside_root_opens(self, jp_fetch):
+        out = await _open(jp_fetch)
+        assert out["cells"] == len(np.load(GOLDEN))
+
+
+class TestLruEviction:
+    @pytest.fixture
+    def hive_config(self):
+        return {"local_hive_store_roots": [str(TESTDATA)], "hive_max_views": 2}
+
+    async def test_third_view_evicts_least_recent(self, jp_fetch):
+        a = await _open(jp_fetch, aoi="4331421")
+        b = await _open(jp_fetch, aoi="4331422")
+        await _open(jp_fetch, aoi="4331421")  # refresh a: b is now LRU
+        c = await _open(jp_fetch, aoi="4331424")
+        with pytest.raises(HTTPClientError) as e:
+            await jp_fetch("gridlook", "hive", b["view"], "zarr.json")
+        assert e.value.code == 404
+        assert b"evicted" in e.value.response.body
+        for alive in (a, c):
+            resp = await jp_fetch("gridlook", "hive", alive["view"], "zarr.json")
+            assert resp.code == 200
+
+
+class TestOversizeView:
+    @pytest.fixture
+    def hive_config(self):
+        return {"local_hive_store_roots": [str(TESTDATA)], "hive_max_cells": 10}
+
+    async def test_whole_store_413(self, jp_fetch):
+        with pytest.raises(HTTPClientError) as e:
+            await jp_fetch("gridlook", "hive", "open", params={"store": str(SERC)})
+        assert e.value.code == 413
+        assert b"hive_max_cells" in e.value.response.body
+        assert b"aoi=" in e.value.response.body
+
+
+class TestConcurrentBuildBound:
+    @pytest.fixture
+    def hive_config(self):
+        # Fewer permitted concurrent builds than the burst below: the extras
+        # must queue on the semaphore, not fail.
+        return {"local_hive_store_roots": [str(TESTDATA)], "hive_max_concurrent_builds": 2}
+
+    async def test_burst_of_opens_all_succeed(self, jp_fetch):
+        import asyncio
+
+        # Four distinct selections (distinct view ids ⇒ four real builds) opened
+        # at once; with a bound of 2 the extras wait, and all four still 200.
+        aois = ["4331421", "4331422", "4331424", "4331421,4331422"]
+        outs = await asyncio.gather(*(_open(jp_fetch, aoi=a) for a in aois))
+        assert len({o["view"] for o in outs}) == 4
+        for o in outs:
+            assert o["cells"] > 0