diff --git a/RELEASE_NOTES.md b/RELEASE_NOTES.md
index 5d0ace25f..1d7bd308c 100644
--- a/RELEASE_NOTES.md
+++ b/RELEASE_NOTES.md
@@ -46,6 +46,87 @@ XXX version-specific blurb XXX
   requirements, environment precedence, caching, and diagnostics. Corrected the
   generated allocation declaration that caused an Apple Clang warning.
 
+### Caterva2 repository access
+
+- Show unobtrusive animated loading dots in b2view's data-pane border while
+  background metadata/previews/pages are pending, without hiding current data.
+
+- Browse fsspec `.b2` document carriers with bounded range-based metadata and
+  chunk reads, original-name previews and streamed decoded copies. HTTP requires
+  validated byte-range responses; native dataset behavior remains unchanged.
+
+- Raise document chunk limits to 32 MiB compressed / 256 MiB decoded for
+  Caterva2 files and local `.b2` carriers. Preview and per-read limits remain
+  unchanged; even a small preview may decode a complete 256 MiB chunk.
+
+- Display saved PNG/JPEG notebook outputs beneath their cells in b2view, using
+  passive terminal-image rendering with shared image-count/byte/pixel limits.
+  Invalid images retain readable cells; HTML, SVG, scripts and widgets stay disabled.
+
+- Reduce b2view startup and remote-page flicker by sizing requests after layout,
+  retaining visible metadata/data during reloads, and reusing buffered rows for
+  height-only resizes instead of fetching them again.
+
+- Restore tagged non-finite floating-point schema values from strict-JSON
+  Caterva2 metadata, preserving NaN/infinity null sentinels and defaults.
+
+- Empty lazy Parquet table slices no longer read row data or scan dictionaries,
+  fixing slow Caterva2 schema fetches. Small slices/takes build dictionaries from
+  selected rows instead of scanning every row group; native table dictionaries
+  retain their existing copy behavior.
+
+- b2view now exits cleanly with a clear diagnostic and nonzero status when
+  its initial source cannot be opened, rather than leaving an unusable TUI.
+
+- b2view file fallback panels distinguish unavailable previews, missing optional
+  dependencies and read/display failures, with consistent capability-aware
+  action hints. Preview errors retain file metadata and redact transport URLs.
+
+- Open local and direct-fsspec ordinary files in b2view with the same bounded
+  text/image previews, PDF fallbacks and explicit copy/external-open actions.
+  Transfers are streamed, cancellable and atomic, with no overwrite by default;
+  existing container/dataset opening remains unchanged.
+
+- Open ordinary local/fsspec directories as lazy b2view tree roots. Preview
+  files and expand dataset containers in place; local symlinks are not followed.
+
+- Use Ctrl+F to filter discovered tree paths without network access, or explicitly
+  search local/Caterva2/fsspec hierarchies recursively with progress, cancellation
+  and discovery limits. Selecting a result reveals it in the existing tree.
+
+- Preview local compressed documents such as `README.md.b2` and `photo.png.b2`
+  using bounded, lazy SChunk decoding. Copies stream original bytes under the
+  original filename; oversized chunks and non-document container types are refused.
+
+- Preview nbformat-4 Jupyter notebooks passively in b2view: Markdown, highlighted
+  code and bounded saved plain-text outputs, with a raw-JSON toggle. No kernels
+  or active HTML/media rendering; supported across existing file backends.
+
+- Fix structured and subarray dtype decoding in `C2Array` and synthesized
+  RemoteStore chunks, including compound/subarray HDF5 leaves.
+
+- Ordinary Caterva2 files now open lazily as `RemoteFile`: bounded original-byte
+  reads, shared compressed-chunk caching, and atomic streaming downloads.
+- b2view previews text/Markdown and optional JPEG/PNG images (`blosc2[images]`).
+  PDF and other unrenderable content remain downloadable; supported documents
+  can open externally through the explicit `O` action and destination dialog. No PDF dependency is
+  required. `D` downloads, `O` opens externally, and `T` toggles raw Markdown.
+
+- `blosc2.open()` recognizes HTTP(S) dataset URLs such as
+  `http://localhost:8000/@public/group`, including deployment prefixes and IPv6.
+  String service URLs default to lazy access; explicit `URLPath` behavior is unchanged.
+- Bare server/base URLs discover `api/roots`. One root opens directly; empty or
+  multiple-root services return a lazy `RemoteRepository` browsing facade.
+- `remote_service="auto" | "caterva2" | "fsspec"` controls service recognition
+  independently of source format. The fsspec override preserves ordinary URLs
+  with literal `@` path components and disables service probes.
+- Caterva2 `RemoteStore` groups expand lazily, including catalog mount boundaries;
+  catalog annotations are separate from source attributes.
+- `b2view` browses these server/root URLs with the existing interface, including
+  bounded array/table previews. Remote table-wide transforms are disabled;
+  plotting requires an explicit bounded row window. Client caches are separate
+  from a shared cat2lite server cache; repository allowances are per root.
+
 ## Changes from 4.14.0 to 4.14.1
 
 Python-Blosc2 4.14.1 is a security and feature release introducing safe
diff --git a/doc/getting_started/installation.rst b/doc/getting_started/installation.rst
index 8d51e063c..fd0e689de 100644
--- a/doc/getting_started/installation.rst
+++ b/doc/getting_started/installation.rst
@@ -33,10 +33,13 @@ grouped into *extras* that you opt into with the ``blosc2[extra]`` syntax:
      - The :doc:`b2view <../guides/b2view>` terminal browser (``textual``,
        ``textual-plotext``), including its in-terminal braille plot (the
        ``p`` key).  Required by the ``b2view`` command.
-   * - ``hires``
+    * - ``hires``
      - The high-resolution image view in b2view (the ``h`` key), which
        renders a real ``matplotlib`` image in the terminal
-       (``textual-image``, ``matplotlib``).  Includes ``tui``.
+        (``textual-image``, ``matplotlib``).  Includes ``tui``.
+    * - ``images``
+      - JPEG/PNG ordinary-file previews in b2view (``Pillow``, ``textual-image``).
+        Includes ``tui`` without requiring matplotlib. ``hires`` includes this extra.
    * - ``parquet``
      - The ``parquet-to-blosc2`` converter (``pyarrow``); see
        :doc:`../guides/parquet_to_blosc2`.
@@ -59,6 +62,7 @@ argument in shells like ``zsh`` that treat brackets specially):
 .. code-block:: console
 
     pip install "blosc2[tui]"             # the b2view terminal browser
+    pip install "blosc2[images]"          # b2view + JPEG/PNG file previews
     pip install "blosc2[hires]"           # b2view + its high-res view (h key)
     pip install "blosc2[parquet]"         # the Parquet converter
     pip install "blosc2[fsspec]"          # fsspec URLs, including HTTP(S)
diff --git a/doc/guides/b2view.rst b/doc/guides/b2view.rst
index c980e3f7b..d40ac56db 100644
--- a/doc/guides/b2view.rst
+++ b/doc/guides/b2view.rst
@@ -63,6 +63,258 @@ You can also jump straight to a node and panel:
 Remote containers and arrays
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
+Caterva2 and shared cat2lite repositories
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Open a Caterva2-compatible server, a published root, or a selected group/leaf:
+
+.. code-block:: console
+
+    b2view http://localhost:8000
+    b2view http://localhost:8000/@public
+    b2view http://localhost:8000/@public/hdf5 /d0/d1/a2
+    b2view https://cat2.cloud/demo/@public/example
+
+A bare server URL probes ``api/roots``. A single visible root opens directly;
+multiple roots appear as children of a repository group. An empty server shows
+"No accessible roots". Deployment prefixes such as ``/demo`` are preserved.
+For scripts and reproducible starting paths, prefer an explicit root URL.
+
+Group expansion discovers mounted hierarchies on demand. Arrays and tables use
+bounded previews/pages through the server API; the viewer does not download the
+whole source container. Catalog annotations appear separately as
+``catalog_attrs`` in metadata, without replacing source attrs.
+
+Use ``--remote-service fsspec`` when an ordinary HTTP data URL happens to contain
+an ``@``-prefixed path component. Use ``--remote-service caterva2`` to require
+service discovery rather than falling back to a file opener.
+
+``--cache-dir`` and ``--max-cache-bytes`` configure the **client** cache, not the
+server's shared cache. Multi-root repository budgets are per opened root.
+The cat2lite administrator configures shared upstream caching independently.
+Sources are assumed immutable; updates require deliberate cache invalidation.
+Overlapping reads across clients benefit most from a shared server cache.
+
+Remote tables support previews and projection, but filtering, sorting, and
+grouping are disabled rather than implicitly downloading the whole table.
+Table plotting requires a bounded locked row window (``v``). Source formats
+behind cat2lite need their dependencies on the server, not on each viewer client.
+
+Ordinary Caterva2 files
+^^^^^^^^^^^^^^^^^^^^^^
+
+Published ordinary files (compressed SChunk byte streams) appear as file nodes.
+Metadata inspection does not fetch their payload. Text and Markdown preview a
+UTF-8 prefix, bounded to 64 KiB and 1,000 lines; truncated/invalid text is labelled.
+Markdown links/images are passive and never fetch other resources. ``T`` toggles
+raw text and Markdown; terminal controls are stripped from file content.
+
+Install ``blosc2[images]`` for JPEG/PNG previews using Pillow and textual-image,
+without requiring matplotlib. Terminal protocol support may fall back to colored
+half-cells. Missing dependencies/display support show a download/open notice.
+Automatic image input is limited to 16 MiB; original pixel count is limited to
+16,777,216 pixels (64 MiB RGBA). Orientation is corrected, the first frame is used,
+and the displayed image is reduced to at most 1600 × 1200 pixels. These limits
+bound individual buffers, not total process RAM including decoder copies.
+
+``D`` prompts for a destination and streams the **original file**, not its Blosc
+carrier. ``O`` downloads and opens the completed local file in the platform's
+external viewer after you submit the destination dialog, without an extra trust
+checkbox. Both actions work for
+PDFs, which deliberately need no terminal PDF renderer. External opening is
+restricted to PDF, JPEG/PNG, Markdown, and text; other binary files remain
+downloadable. No shell or credential-bearing URL is passed to the launcher.
+Downloads are user-owned: they remain after closing the dialog or b2view, including
+when external opening fails. Existing destinations are never overwritten by the
+viewer; choose another name. Escape cancels an active transfer.
+
+File reads/downloads have per-chunk limits of 32 MiB compressed and 256 MiB decoded.
+Animated ``loading`` dots in the data-pane border indicate pending background
+loads without hiding the current page or changing the layout. The indicator
+disappears when the load completes or fails; it is activity, not byte progress.
+Even a small preview can decode one complete chunk; temporary buffers can bring
+peak memory above the decoded-chunk limit. Preview and per-call read limits
+remain independent of these chunk limits.
+A small preview may require a much larger chunk. Oversized or irregular sources
+require server-side rechunking; the viewer never silently fetches a whole file
+to work around these limits. File reference archives are not supported by this
+feature. Incompatible files do not hide healthy
+siblings.
+
+Local and direct-fsspec ordinary files
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Open a regular file directly with the same previews, fallback panels and actions:
+
+.. code-block:: console
+
+    b2view README.md
+    b2view photo.png
+    b2view brochure.pdf
+    b2view https://example.org/README.md
+    b2view --profile blosc2 s3://my-bucket/notes/README.md
+
+Local ``file://`` URLs and fsspec protocol chains are supported too. Install
+``blosc2[fsspec]`` and the relevant filesystem dependency for remote files.
+Authentication/storage options use the same CLI flags as direct dataset URLs.
+For an HTTP file without a filename extension, or a file URL containing an
+``@`` path component, pass ``--remote-service fsspec`` to bypass service discovery.
+
+Direct files open without a tree panel. Reads and image decoding run in the
+background; preview text/image limits are unchanged. ``D`` copies original bytes
+to a chosen local destination; ``O`` copies and opens the supported document
+after explicit destination submission. Local sources are never modified, and
+existing destinations are not overwritten. Choose a different destination when
+the dialog defaults to the source's own name. Transfers stream in 1 MiB spans
+and support cancellation and atomic publication, rather than loading the whole
+file into memory. Ordinary files must have a known size; a short read or a size
+change during copying fails without publishing a partial destination.
+
+These viewer-only handles do not extend ``blosc2.open`` or Caterva2's caches.
+``--cache-dir``/``--max-cache-bytes`` do not configure direct ordinary-file caching;
+filesystem backends may have their own buffering (notably chained archives).
+HTTP operations have a default 10-second timeout. Existing Blosc2/Zarr/HDF5
+hierarchies keep their dataset semantics.
+Recognized dataset extensions retain their normal opener and corruption errors;
+unrecognized filenames receive a small native-frame signature check, not object
+deserialization or automatic content execution.
+
+Ordinary directories
+^^^^^^^^^^^^^^^^^^^^
+
+Local directories (including ``file://`` URLs) and directories on fsspec
+filesystems with directory-listing support open as lazy tree roots:
+
+.. code-block:: console
+
+    b2view ./documents/
+    b2view ../cat2lite/tests/fixtures/data-cat2-demo/root-example/
+    b2view --profile blosc2 s3://my-bucket/documents/
+
+Only immediate children are listed; expanding a directory discovers the next
+level. Selecting a file uses the same previews and copy/open actions as a direct
+file input. Dataset containers such as B2Z, HDF5 and Zarr can be expanded as
+mounted subtrees without first downloading the whole container. A corrupt leaf
+does not hide its siblings. Refresh reopens the directory and its selected node.
+Local symlinks are shown but not followed, and parent-path navigation cannot
+escape the opened root. Opening a dataset directory such as ``.b2d`` or ``.zarr``
+directly continues to use the dataset opener, not the ordinary-directory browser.
+Client cache directories are separated per mounted dataset; cache-byte budgets
+apply per mounted source, not as a global limit for the whole directory tree.
+
+Compressed local and fsspec documents
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Document carriers such as ``README.md.b2``, ``photo.png.b2`` and
+``brochure.pdf.b2`` use the same file previews/actions as their originals:
+
+.. code-block:: console
+
+    b2view README.md.b2
+    b2view ./documents/ /README.md.b2
+    b2view s3://bucket/documents/README.md.b2
+    b2view https://example.org/documents/analysis.ipynb.b2
+
+Supported text, JPEG/PNG and PDF suffixes followed by ``.b2`` identify this
+viewer-only convention. A carrier must be a plain fixed-chunk SChunk byte stream,
+not an NDArray, serialized object or remote reference. Local carriers are mapped
+read-only; fsspec carriers use byte ranges on contiguous frames. Metadata
+inspection does not decompress document chunks. Plain ``data.b2`` and
+``.b2frame`` datasets keep their normal native behavior.
+
+Remote reads fetch the frame header, then a bounded chunk index when values are
+first requested, and each needed chunk's header before its payload. HTTP servers
+must return valid ``206`` byte-range responses; ignored ranges, incorrect
+lengths and encoded responses are refused without reading the complete body.
+Frame headers are capped at 1 MiB and chunk indexes at 8 MiB compressed/decoded.
+Sparse frames and nonzero special-value chunks are not supported remotely.
+Filesystem storage options (including authentication) apply to previews and
+independent transfer handles. Other fsspec backends may have their own buffering.
+
+Text previews decode only chunks covering the first 64 KiB, displaying at most
+1,000 lines. Images decode complete original bytes only within the existing
+16 MiB input and pixel limits. PDF selection needs no decompression. Chunk
+headers are checked before copying/decompressing payload: each chunk must fit
+32 MiB compressed and 256 MiB decoded. Oversized/irregular carriers are refused;
+rechunk them rather than increasing automatic preview memory usage.
+
+``D`` streams decoded original bytes to the destination, keeping at most one
+decoded chunk between reads. ``O`` uses the same explicit copy/external-open
+workflow. Both suggest the original name (``README.md``, not ``README.md.b2``);
+carrier metadata retains the on-disk filename. No entire document is assembled
+for downloading, and no original-file payload is deserialized or executed.
+Sources are assumed immutable while open; refresh after replacing a carrier.
+
+Passive Jupyter notebook previews
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+``.ipynb`` files open as passive nbformat-4 documents, not executable notebooks:
+
+.. code-block:: console
+
+    b2view analysis.ipynb
+    b2view analysis.ipynb.b2
+    b2view https://cat2.cloud/demo/@public/examples/slice-time.ipynb
+
+Markdown cells render without active links/images; code cells are syntax
+highlighted using the declared supported language (otherwise plain text).
+Raw cells, saved stdout/stderr, plain-text result representations and tracebacks
+are shown as text with terminal controls removed. No kernel starts, cells never
+execute. Saved PNG/JPEG outputs are decoded from the notebook and displayed
+beneath their cells using the existing terminal-image support
+(``blosc2[images]``). HTML/JavaScript, SVG, widget outputs and other media remain
+omitted with a notice. There is no requirement for Jupyter or nbformat to be
+installed. Markdown image links/attachments are not fetched.
+
+At most eight saved images are displayed. They share a 16 MiB encoded-image-byte
+budget and a 16,777,216 decoded-pixel budget (64 MiB at RGBA), in addition to the
+2 MiB notebook input cap below. Images are validated before pixel decoding and
+reduced to at most 1600 by 1200 pixels for display. Invalid or oversized images
+are skipped with a notice, keeping cell text available. Only saved static
+images are shown; interactive plots/widgets are not executed, and animated
+images show only their first frame.
+
+Parsing requires the complete JSON document, so input is capped at 2 MiB.
+Displayed source/output text shares a 64 KiB / 1,000-line budget, with at most
+100 cells. Truncation is labelled; oversized or unsupported notebooks show the
+normal fallback panel rather than being fetched without bounds. ``T`` switches
+between the cell view and a bounded raw-JSON prefix; ``D`` copies the original
+notebook. Notebook external opening is not enabled. These previews work with
+local, fsspec and Caterva2 files, and local/fsspec ``.ipynb.b2`` document carriers, under
+their existing transport/chunk limits.
+
+Find nodes in local or remote trees
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+Press ``f`` with the tree focused, or ``ctrl+f`` from any panel, to open tree
+search. The tree frame includes a compact key hint. Typing filters **already discovered** paths
+by case-insensitive substring, without network requests. Matching nodes retain
+their ancestor context. An empty filter shows discovered nodes again; Escape
+closes the dialog without changing the main tree's selection or expansion state.
+The dialog displays at most 500 matches at once; refine the filter for more.
+
+Choose **Search recursively** to discover unopened directories/groups in the
+background. This works with local trees, Caterva2 repositories and fsspec
+hierarchies using their existing listing APIs. It requests listings and necessary
+metadata, not file previews, array values or table rows. For example, Caterva2
+table classification can require an empty frame containing its schema.
+
+Progress, listing errors and incomplete/cancelled status are shown explicitly.
+Search stops after 200 directories, 10,000 discovered nodes or depth 12; the final
+indivisible backend listing can exceed the node budget. **Cancel search** retains
+completed results; Escape cancels and closes. An in-flight backend operation may
+finish before cancellation takes effect, but the dialog can close immediately.
+Discovered listings are reused in subsequent searches; refresh the tree to
+invalidate them. No recursive discovery happens merely by typing a filter.
+
+Press Enter in the input to focus the result tree, then select a matching node
+with Enter (or the mouse) to reveal its ancestors in the main tree and open its
+normal preview. Row/column filtering shortcuts remain unchanged. Standalone
+files and arrays have no tree to search.
+
+Direct source URLs
+^^^^^^^^^^^^^^^^^^
+
 Browse remote B2Z, Zarr, and HDF5 containers directly from their root:
 
 .. code-block:: console
diff --git a/doc/guides/remote_arrays.md b/doc/guides/remote_arrays.md
index 1af2e7d80..39e23f055 100644
--- a/doc/guides/remote_arrays.md
+++ b/doc/guides/remote_arrays.md
@@ -216,6 +216,10 @@ Shared caching selects lazy access for every remote source when `lazy` is
 omitted or `None`; explicit `lazy=False` is rejected.
 Authentication from `URLPath` or `c2context` remains
 in process memory. Authenticated users must use separate cache directories.
+Automatic service discovery inherits credentials only when the destination has
+the same scheme, host, and port as the configured `c2context(urlbase=...)`.
+Other origins are probed and browsed anonymously; explicitly select a Caterva2
+service or provide an authenticated `URLPath` to authorize another destination.
 All handles using a shared cache must enable sharing. For advanced attachment
 with seed carriers or authorized sources, `RemoteArray.with_sparse_cache()`
 remains available.
diff --git a/doc/guides/remote_objects.md b/doc/guides/remote_objects.md
index 3f799142a..657265d16 100644
--- a/doc/guides/remote_objects.md
+++ b/doc/guides/remote_objects.md
@@ -8,12 +8,20 @@ one API. Data is read on demand and cached locally; remote sources are read-only
 | Standalone `.b2nd`, or a B2Z/Zarr/HDF5 array | {ref}`RemoteArray` |
 | Parquet file, B2Z CTable, PyTables table, or Caterva2 table | {ref}`RemoteCTable` |
 | B2Z, Zarr, HDF5, or Caterva2 group | {ref}`RemoteStore` |
+| Caterva2 ordinary-file / fixed-chunk SChunk byte stream | {ref}`RemoteFile` |
 
-All three inherit {ref}`RemoteObject` and expose source metadata, cache controls,
+These types inherit {ref}`RemoteObject` and expose source metadata, cache controls,
 traffic counters, reference saving, and context-manager support. See
 {doc}`remote_arrays` for array computations and {doc}`remote_tables` for table
 queries and format-specific behavior.
 
+For ordinary Caterva2 files, `file.read_bytes(start, stop)` reads original byte
+ranges and `file.download(destination)` streams original content. Download is
+atomic and refuses overwrite by default. File reference persistence is currently
+unsupported; use download rather than `save`. Fixed-chunk byte streams share
+cache budgets and owner lifetime with array/table leaves, but oversized chunks
+and irregular layouts are refused. See {ref}`RemoteFile` for bounds and callbacks.
+
 ```python
 import blosc2
 
@@ -33,6 +41,57 @@ call. See {doc}`remote_arrays` for local-source caching and selector details.
 
 ## Explore a hierarchy
 
+### Caterva2 servers and shared caching gateways
+
+```python
+with blosc2.open("http://localhost:8000") as repository:
+    print(repository.keys())
+
+with blosc2.open("http://localhost:8000/@public/hdf5") as group:
+    print(group.keys())
+    with group["d0/d1/a2"] as array:
+        values = array[:10, :10]
+```
+
+An HTTP(S) path component starting with `@` identifies a Caterva2 root. The
+preceding path stays in the deployment base, e.g. `https://host/demo/@public`.
+These string service references default to lazy access and return the selected
+group, array, or table type. Explicit `URLPath` inputs retain their existing
+lazy defaults. Dataset selectors are in the service URL, not `path=` or `::`.
+
+An ambiguous bare base URL probes `<base>/api/roots` with a short timeout. A
+single visible root opens directly. Zero or multiple roots return
+{ref}`RemoteRepository`, with root names as children and independent, lazily
+opened root owners. Prefer explicit root URLs for scripts: relative paths on
+a bare service can change if its root count changes. Repository persistence and
+materialization are unsupported; select a specific root for those operations.
+
+Use `remote_service="fsspec"` to disable recognition/probing for ordinary data
+URLs containing `@` components, or for extensionless file sources. Use
+`remote_service="caterva2"` to require a service without file fallback. Known
+direct-format URLs are not probed in auto mode. Malformed/non-service responses
+allow file fallback; authentication, connection, and server errors remain errors.
+Discovery redirects are limited to the same origin. Authentication uses existing
+{func}`blosc2.c2context`/`URLPath` facilities and is bound to opened owners.
+
+Caterva2 groups list immediate children on demand. A catalog mount not expanded
+yet is not treated as empty. Direct descendant lookup also works without parent
+expansion. `RemoteNode.catalog_attrs` contains catalog annotations separately
+from source `attrs`. Existing servers may return recursive listings; their
+response cost cannot be eliminated without a server-side pagination extension.
+Caterva2 discovery retains at most 10,000 nodes per owner by default, rejects
+list responses above 100,000 entries, and rejects discovery bodies above 8 MiB
+before JSON decoding. Existing transports buffer those discovery bodies before
+the size check. Explicit hierarchy summaries (`store.info`) visit groups and can
+contact mounted sources; failures are reported as incomplete listings.
+
+A cat2lite gateway can share cached upstream chunks between independent clients.
+Python-Blosc2's `cache_dir`, `cache_policy`, and `max_cache_bytes` still configure
+the **client** cache. They do not configure the gateway cache, and `shared_cache`
+does not mean “use the server cache.” Repository allowances apply per opened
+root; retained payload totals can therefore exceed a single root's allowance.
+Immutable-source assumptions and explicit invalidation requirements still apply.
+
 - `store.keys()` or iteration lists immediate children.
 - `store["group/array"]` and `store["group"]["array"]` select the same leaf.
 - `store.attrs` exposes group attributes.
diff --git a/doc/reference/classes.rst b/doc/reference/classes.rst
index b4adc0b8b..f783c4919 100644
--- a/doc/reference/classes.rst
+++ b/doc/reference/classes.rst
@@ -156,6 +156,8 @@ container APIs above.
     remoteobject
     remotearray
     remotestore
+    remoterepository
+    remotefile
     remotectable
     proxysource
     proxyndsource
diff --git a/doc/reference/remotefile.rst b/doc/reference/remotefile.rst
new file mode 100644
index 000000000..05f51f1b2
--- /dev/null
+++ b/doc/reference/remotefile.rst
@@ -0,0 +1,45 @@
+.. _RemoteFile:
+
+RemoteFile
+==========
+
+``RemoteFile`` is a read-only Caterva2 fixed-chunk SChunk byte stream. It is
+returned by lazy service leaf opening or ``RemoteStore`` file lookup. Discovery
+and file metadata do not fetch payload. Ordinary files such as Markdown, JPEG,
+and PDF published as compressed byte streams are supported; there is no Python
+object deserialization or implicit interpretation as an array.
+
+.. code-block:: python
+
+    import blosc2
+
+    with blosc2.open("https://cat2.cloud/demo/@public/examples/README.md") as file:
+        prefix = file.read_bytes(0, min(file.nbytes, 4096))
+        file.download("README.md")
+
+``read_bytes(start, stop)`` returns original bytes, with at most 16 MiB per call.
+The omitted stop means the file end, not an unbounded streaming read. Use
+``download`` for larger files. A chunk can contain more data than the requested
+range: transfers are chunk-granular, bounded at 32 MiB compressed and 256 MiB
+decoded per chunk. Oversized/irregular streams require rechunking on the server.
+Generic fixed-chunk typed SChunks expose their raw byte representation; they do
+not imply a text/image/document format.
+
+Downloads stage beside the destination, then publish completed original bytes.
+Existing destinations are not overwritten unless ``overwrite=True`` is explicit.
+No-overwrite publication uses a hard link to prevent concurrent-creation races;
+the destination filesystem must support hard links. ``progress(done, total)``
+and ``cancel()`` callbacks run on the calling thread. Cancellation or failure
+removes only the operation's staging file and preserves any previous destination.
+
+Cache policy/allowance, traffic, and lifetime are shared with the source owner.
+``cache_bytes`` includes other leaves in that owner. MEMORY/DISK retain compressed
+chunks; NONE retains no payload between calls. Transient decoded buffers are
+separately bounded, not included in retained cache bytes. Sources must remain
+immutable until explicit refresh; returned children outlive their parent handle.
+``save`` of a file reference is intentionally unsupported; ``download`` is an
+original-byte export, not a reference archive. Explicit nonlazy ``URLPath`` input
+still requires ``lazy=True`` for byte-stream access.
+
+.. autoclass:: blosc2.RemoteFile
+    :members: read_bytes, download, close, source, name, media_type, nbytes, cbytes, nchunks, chunksize, attrs, traffic, info, cache_policy, max_cache_bytes, cache_bytes, metadata_bytes
diff --git a/doc/reference/remoterepository.rst b/doc/reference/remoterepository.rst
new file mode 100644
index 000000000..5c1cb1b29
--- /dev/null
+++ b/doc/reference/remoterepository.rst
@@ -0,0 +1,29 @@
+.. _RemoteRepository:
+
+RemoteRepository
+================
+
+``RemoteRepository`` is a read-only browsing facade returned by
+``blosc2.open("https://host/base")`` when a Caterva2-compatible service has zero
+or multiple accessible roots. A single root instead opens directly.
+
+The facade subclasses :ref:`RemoteStore` for hierarchy consumers such as b2view.
+``keys()`` lists roots without opening them; ``repository["@public"]`` returns
+an independent group handle. Direct descendant lookup is supported. Closing
+the repository leaves previously returned child handles usable. Alias handles
+from ``repository[""]`` share root owners and lifetime accounting.
+
+Cache policy and allowance are per root. ``cache_bytes`` and ``metadata_bytes``
+sum opened roots; ``traffic`` counts their reads and excludes the initial roots
+probe. Source descriptors contain no authentication token. Root owners bind the
+authentication context at repository creation and use existing isolated cache
+identities.
+
+Repository persistence, materialization, refresh, and root-level shared sparse
+cache opening are intentionally unsupported. Select a specific root for those
+operations. ``get_info`` at a root name reports the roots registry metadata;
+select/open that root for its actual source attributes. No synthetic empty path
+is sent to the server's info endpoint.
+
+.. autoclass:: blosc2.RemoteRepository
+    :members: keys, get_info, close, source, attrs, cache_policy, max_cache_bytes, cache_bytes, metadata_bytes, traffic
diff --git a/doc/reference/remotestore.rst b/doc/reference/remotestore.rst
index b5c7884f9..2a4ed1890 100644
--- a/doc/reference/remotestore.rst
+++ b/doc/reference/remotestore.rst
@@ -8,6 +8,13 @@ RemoteStore
 source session: a B2Z archive, a native HDF5 index, or a Zarr store. Zarr listing
 remains lazy.
 
+Caterva2 groups also list lazily, through explicit ``URLPath`` inputs or service
+URL strings passed to ``blosc2.open``. Each group is expanded independently,
+including virtual catalog mount boundaries. ``RemoteNode.catalog_attrs`` exposes
+catalog annotations separately from source attrs. See
+:doc:`../guides/remote_objects` for URL discovery and :ref:`RemoteRepository`
+for browsing services with multiple roots.
+
 The default ``CachePolicy.MEMORY`` shares a 256 MiB allowance across all leaves.
 Set ``max_cache_bytes`` to a positive integer to change it. ``CachePolicy.NONE``
 retains no payload and rejects a limit. Passing ``cache_dir`` selects DISK when
diff --git a/plans/b2view-tree-search.md b/plans/b2view-tree-search.md
new file mode 100644
index 000000000..16641b1e5
--- /dev/null
+++ b/plans/b2view-tree-search.md
@@ -0,0 +1,22 @@
+# b2view tree search
+
+Implemented following user authorization. F with tree focus (or global Ctrl+F)
+opens a filtered mirror of
+discovered nodes; case-insensitive path filtering performs no I/O. Ancestors
+remain visible, and closing restores the unchanged main tree selection/expansion.
+
+Explicit recursive search traverses existing StoreBrowser listings breadth-first
+on a worker, reusing known listings. Local, Caterva2 and fsspec roots use the same
+implementation. It does not call preview/data access: necessary discovery
+metadata (including empty Caterva2 table schema frames) is allowed.
+
+Limits: 200 directories, 10,000 nodes, depth 12; the final atomic listing may
+overshoot the node count. Only 500 matches are rendered at once. Progress is
+throttled to keep result-tree rebuilding responsive. Cancellation and session
+guards reject obsolete callbacks/results; in-flight provider calls cannot be
+forcibly interrupted. Errors and partial-search status are reported explicitly.
+
+Selecting a result merges discovered listings and reveals the node using normal
+navigation. Closing retains delivered discoveries without expanding the main
+tree; refresh invalidates extra discovery snapshots. No backend-specific global
+catalog optimization or filename-content/full-text search is introduced.
diff --git a/plans/caterva2-access-improvements.md b/plans/caterva2-access-improvements.md
new file mode 100644
index 000000000..60fc91517
--- /dev/null
+++ b/plans/caterva2-access-improvements.md
@@ -0,0 +1,464 @@
+# Caterva2 access improvements for Python-Blosc2 and b2view
+
+Status: M0–M5 implemented and validated on `cat2-improvements`; final review
+fixes included. The sections below retain the delivery design and acceptance
+criteria; the implementation record is the authoritative completion evidence.
+
+Implementation record (updated as milestones land):
+
+- M0/M1: selected `remote_service="auto" | "caterva2" | "fsspec"` and
+  implemented root-marker recognition before format dispatch. String service
+  URLs default to lazy access; explicit URLPath defaults remain unchanged.
+  Inspection confirms `open` currently defaults to `mode="r"` (the proposal's
+  concern about changing that default requires no code change).
+- Repository design: use a public RemoteRepository subclass of RemoteStore as
+  a browsing facade with independently owned roots and per-root cache budgets.
+  Repository persistence is explicitly unsupported initially. Single-root
+  servers flatten to their actual root object; empty/multi-root servers return
+  the repository facade. Root owners stay alive through normal returned child
+  handles after the facade closes.
+- Roots discovery uses the mapping response implemented by cat2lite and
+  Caterva2, not an assumed list. No global discovery cache is introduced.
+- M1 validation: 20 offline URL/dispatch tests passed in the blosc2 environment.
+- M2: Caterva2 groups now discover immediate children on demand, support direct
+  descendant lookup, memoize completed listings under the owner lock, and roll
+  back node-limit failures. Opening a string root uses the opener's metadata
+  seed to avoid duplicate info calls. Catalog annotations are exposed separately
+  on RemoteNode and retained in discovery metadata. Focused URL/Caterva2 tests:
+  37 passed, including existing reference/table/cache regressions.
+- M3: added bounded roots discovery (3-second deadline, 1 MiB response bound,
+  same-origin redirects only), direct-source bypass, strict error/fallback
+  classification, and the public RemoteRepository browsing facade. Roots open
+  independently and lazily; facade aliases share owners, returned children
+  outlive the facade, and authentication is frozen at opening. Per-root cache
+  budgets and unsupported repository persistence are explicit. Validation:
+  38 access tests passed, including zero/one/multiple roots and error handling.
+- M4: b2view uses shared service recognition ahead of direct-format handling,
+  supports the backend override, displays catalog annotations and empty-root
+  notices, and keeps mounted-source metadata failures isolated. Remote table
+  metadata/paging work without table-wide downloads; transforms are disabled
+  and plotting requires an explicit bounded row window. Fixed metadata display
+  for remote sources that do not report compressed size. All viewer/model
+  regressions, including headless Textual and fresh-process decoders: 155 passed.
+- M5: added opt-in `tests/test_caterva2_gateway.py` against a real debug
+  cat2lite server and deterministic loopback B2ND/HDF5/Zarr/Parquet sources,
+  including headless b2view and independent no-client-cache subprocesses.
+  Measured large-array upstream reads: 72,950 bytes / 3 GETs after warming;
+  second client unchanged; after server restart 81,142 bytes / 4 GETs (8 KiB
+  source headers, no warm payload refetch). API/viewer docs and release notes
+  updated. Full default offline suite: 10,640 passed, 36 skipped. Gateway
+  acceptance passed with CAT2LITE_SERVER set; it is skipped by default.
+- Final review: old eager-list cache snapshots rediscover listings without
+  discarding retained payload; direct paths reject query/fragment/escape
+  ambiguity; missing nodes raise KeyError; nonlazy groups/tables fail clearly.
+  Added default node/list/discovery-response limits, avoided full-registry copies
+  per node inspection, and isolated failed sources in hierarchy summaries.
+  Failed viewer nodes remain expandable for retry. Row-window reads are prepared
+  in background workers and published only if selection/session still match;
+  Caterva2 windows materialize explicitly bounded selections for local plotting.
+- Final validation: 10,646 default-suite tests passed, 37 skipped (including
+  the opt-in gateway test); 213 focused access/Caterva2/viewer/model tests passed
+  with headless TUI cases enabled; real cat2lite gateway acceptance passed again
+  with the same cache traffic measurements. Ruff lint/format and diff checks
+  passed. HTML docs built in external temporary storage with notebook execution
+  disabled, generated/stashed doc copies excluded, and type-comment introspection
+  disabled; the wider documentation build still emits many autosummary/theme/
+  cross-reference warnings (754), so this is not a warnings-clean documentation
+  build. No Python native-extension rebuild was required; cat2lite's three debug
+  binaries were rebuilt for cross-project acceptance.
+
+## 1. Goal
+
+Make Caterva2-compatible servers, including cat2lite, first-class URL-addressable
+sources in Python-Blosc2. Users should be able to browse a curated remote
+repository through a shared caching gateway with the same viewer and opening
+API used for individual files.
+
+Target usage:
+
+```python
+import blosc2
+
+repository = blosc2.open("http://localhost:8000", mode="r")
+public = blosc2.open("http://localhost:8000/@public", mode="r")
+group = blosc2.open("http://localhost:8000/@public/hdf5", mode="r")
+array = blosc2.open("http://localhost:8000/@public/hdf5/d0/d1/a2", mode="r")
+```
+
+```sh
+b2view http://localhost:8000
+b2view http://localhost:8000/@public
+b2view https://cat2.cloud/demo/@public/example
+```
+
+The examples above describe implemented behavior. Preserve existing direct-file
+opening, including HTTP B2ND/B2Z, HDF5, Zarr, and Parquet sources.
+
+Architecture:
+
+```text
+b2view / Python applications
+          |
+          | Caterva2 metadata, listings, bounded slices
+          v
+cat2lite + shared server-side disk cache
+          |
+          v
+remote repositories exposed through .catl mounts
+```
+
+Do not create a separate cat2lite-view application. Source recognition belongs
+in Python-Blosc2; the existing b2view UI should consume the resulting objects.
+
+## 2. Current implementation and gaps
+
+Relevant code to inspect before implementation:
+
+- `src/blosc2/schunk.py`: `open`, `_open_c2_urlpath`, remote option validation,
+  lazy dispatch, and existing format-specific openers.
+- `src/blosc2/c2array.py`: `URLPath` integration, API URL construction, shared
+  HTTP clients, authentication, info/list/fetch helpers.
+- `src/blosc2/remote_store.py`: Caterva2 source descriptors, `_open_caterva2`,
+  `resolve`, `kind`, `list_children`, owner/cache lifecycle, and table fetching.
+- `src/blosc2/b2view/model.py`: `StoreBrowser._open_store`, tree traversal,
+  remote leaf ownership, previews, and table capabilities.
+- `src/blosc2/b2view/app.py`: background opening, tree expansion, failure display.
+- `src/blosc2/b2view/cli.py`: source arguments, cache options, initial path.
+
+Existing foundations:
+
+- Explicit `blosc2.URLPath(path, urlbase=...)` already selects Caterva2 handling.
+- The lazy Caterva2 opener discovers groups, arrays, and CTables; groups can
+  return `RemoteStore`, arrays use existing C2Array/RemoteArray semantics, and
+  tables can return `RemoteCTable`.
+- b2view already displays RemoteStore hierarchies and remote leaves.
+- cat2lite already implements roots, info, list, and bounded data access.
+
+Gaps:
+
+1. A plain HTTP string is not converted into a Caterva2 URLPath.
+2. Bare server URLs are treated as data files, without roots discovery.
+3. `_open_caterva2` currently assumes an initial recursive listing describes the
+   hierarchy and initializes discovered groups' child lists from that snapshot.
+   cat2lite catalog listings deliberately stop at mounted-source boundaries.
+   Thus a discovered mounted group can appear empty instead of being expanded
+   through another API list request.
+4. b2view has format-specific URL dispatch that must not override the new
+   Caterva2 interpretation when a published dataset name ends in `.h5`, etc.
+5. A server with multiple roots has no agreed repository-level browsing object.
+
+## 3. URL and opening contract
+
+### 3.1 Explicit dataset/group shorthand
+
+Recognize an HTTP(S) URL containing an `@`-prefixed path component as Caterva2
+shorthand, consistently with cat2lite's `.catl` convention.
+
+Example:
+
+```text
+https://host/demo/@public/group/array
+  urlbase = https://host/demo
+  path    = @public/group/array
+```
+
+Rules:
+
+- Parse with a real URL parser, preserving bracketed IPv6 and port numbers.
+- Inspect path components only; ignore `@` in hostname, userinfo, or query.
+- Use the first root-marker component; later `@` components are dataset names.
+- Preserve the encoded deployment prefix; decode logical dataset components
+  exactly once and use existing Caterva2 path validation/endpoint encoding.
+- Reject empty root markers, traversal, encoded separators, malformed encoding,
+  control characters, and unsupported query/fragment/selector combinations.
+- Do not reinterpret fsspec `::/member` selectors as Caterva2 dataset selectors.
+- Authentication uses existing Caterva2 facilities, not URL userinfo.
+- Explicit URLPath inputs retain precedence and behavior.
+- Return the object's actual type; do not wrap every dataset in RemoteStore.
+- Preserve existing `mode`, `offset`, `lazy`, and cache-option validation.
+  Remote sources remain read-only. Specify `mode="r"` in documentation rather
+  than changing the global default mode as part of this work.
+- `lazy=False` must retain its existing meaning or explicitly reject group/
+  repository opening; do not silently ignore it to force browser semantics.
+
+### 3.2 Ordinary HTTP override
+
+An ordinary file server can legitimately contain `@` path components. Provide
+an explicit bypass for Caterva2 recognition and repository probing.
+
+Selected API: the narrowly scoped selector
+`remote_service="auto" | "caterva2" | "fsspec"` on `blosc2.open`.
+This selects the service backend independently of data format; do not
+overload `source_format`, which currently describes data formats.
+
+- `auto`: root-marker shorthand, known-file dispatch, then eligible base probe.
+- `caterva2`: explicitly interpret a URL as a repository base or dataset URL.
+- `fsspec`: use the ordinary fsspec-backed source handling, even with `@`
+  components, bypassing Caterva2 recognition and probing. This identifies the
+  access backend, not a local file or a single-file-only source; remote
+  containers and stores remain supported.
+- Explicit URLPath plus a conflicting override is an error.
+- Reject this option for inputs where it has no meaning rather than ignoring it.
+- If needed, expose the same choice in b2view through a small CLI flag.
+
+### 3.3 Bare server and deployment-base URLs
+
+For an eligible ambiguous HTTP(S) URL, probe `<base>/api/roots` with a bounded
+timeout and validate the response against the actual Caterva2 roots contract.
+Inspect both Caterva2 and cat2lite responses during M0; do not assume a list
+of root names if the API returns a mapping with metadata.
+
+Recommended dispatch order:
+
+1. Explicit URLPath or explicit service override.
+2. Root-marker URL shorthand.
+3. Known file/container URL, including selectors and trailing-slash Zarr.
+4. Discovery for ambiguous base candidates, including `/demo` prefixes.
+5. Existing generic remote-file path if discovery conclusively says this is
+   not a Caterva2-compatible server.
+
+Discovery must not add roots requests to recognized direct-file reads or turn
+an existing permission/format error into an unrelated service-detection error.
+
+Probe handling:
+
+- Valid roots response: bind the server base and authentication context.
+- Missing endpoint, HTML, malformed JSON, or invalid schema: classify as
+  non-Caterva2 in auto mode; provide a clear discovery error in explicit mode.
+- 401/403: report authentication/authorization failure; no anonymous fallback.
+- Connection/TLS failure or timeout: report an actionable connection error,
+  preserving the original cause; avoid serial retry/fallback delays.
+- Server errors: preserve the server error rather than saying “not Caterva2”.
+- Preserve deployment prefixes and follow existing redirect policy. Never
+  forward authentication credentials to an unrelated redirect origin.
+- Close response resources, reuse the existing transport, and avoid duplicate
+  roots/info requests when passing discovery results into an owner.
+- Do not introduce a process-global negative discovery cache initially.
+  Any later positive cache must include authentication identity and lifetime.
+
+## 4. Repository root behavior
+
+Recommended user-facing behavior:
+
+- Exactly one root: open it directly, so cat2lite's `@public` server feels like
+  a directly opened hierarchy.
+- Multiple roots: expose a synthetic repository group with roots as children.
+- Zero visible roots: return an empty repository group, with b2view showing
+  “No accessible roots”; this is not necessarily a server error.
+- An explicit `/@public` URL always opens that root, regardless of other roots.
+
+Implementation decision for M0: prefer a repository-backed RemoteStore mode
+over a viewer-only wrapper. Confirm it fits ownership and persistence semantics
+before choosing a new public class. All applications should get the same
+`keys`, lookup, `kind`, attrs, context-manager, and close behavior.
+
+The synthetic group:
+
+- Is not sent to `/api/info` as a fabricated empty dataset path.
+- Discovers each root only when accessed; it does not open all roots at startup.
+- Isolates inaccessible/broken roots without hiding healthy siblings.
+- Has its own identity distinct from a dataset-root descriptor.
+- Keeps independent root owners under a repository lifetime; closing the
+  repository must follow existing live-child ownership conventions.
+- Makes cache allowance scope explicit. Prefer a repository-wide bound where
+  the owner architecture supports it; otherwise document per-root allowances
+  before shipping rather than implying a total bound.
+- Either defines safe persistence/reopening explicitly or rejects repository
+  persistence clearly in the first implementation. In-memory browsing must
+  not accidentally write an invalid existing dataset descriptor.
+
+Single-root flattening means relative paths can change if server roots change
+between opens. Document this and recommend explicit root URLs for scripts.
+
+## 5. Lazy Caterva2 hierarchy discovery
+
+Refactor Caterva2 discovery into separate root metadata, node metadata, and
+group-listing operations. Track whether a group has actually been listed;
+“known group with no discovered children” is not “known empty group”.
+
+Required behavior:
+
+1. Open a known root with bounded metadata work, without recursive remote
+   source expansion.
+2. Expand a group through `/api/list/<path>` only when needed.
+3. Accept existing recursive relative-path lists and catalog lists that stop
+   at mounts. Synthesize structural parent groups where necessary.
+4. Mark only the queried group's listing as complete. A returned group may
+   need its own request, even if no descendants were returned initially.
+5. Fetch and memoize metadata needed to classify actual children. Do not
+   assume every listed name is an array or eagerly inspect every deep leaf.
+6. Resolve a directly requested descendant through info requests even when its
+   parents have not been expanded. Update the same node registry afterward.
+7. Keep listings deterministic and deduplicated; empty groups remain visible.
+8. Bound node growth and discovery work; reject malformed or escaping paths.
+9. Coalesce concurrent discovery for the same group and publish registry
+   updates atomically. Failed discovery must remain retryable.
+10. Preserve attrs and separate `catalog_attrs` annotations without overwriting
+    source attrs. Decide how annotations are displayed in b2view metadata.
+
+There is a protocol constraint: an existing server may return a large recursive
+list in a single response. This client change cannot promise paginated or
+constant-size listings without a server API extension. Avoid eagerly fetching
+info for every returned descendant; measure remaining list costs separately.
+
+## 6. Cache and data-access semantics
+
+- A cat2lite server cache is shared across its HTTP clients. Python-Blosc2's
+  client cache is a separate layer, with independently configured policies.
+- Reuse existing none/memory/disk options; do not invent a special server-cache
+  policy or reinterpret `shared_cache=True` as “use cat2lite”. That existing
+  option has its own local-cache semantics and locking requirements.
+- Normalize shorthand strings and equivalent URLPath sources to the same
+  dataset cache identity, including base prefix, path, and authentication scope.
+- Repository synthetic identities must not collide with dataset identities.
+- Do not persist credentials or allow a cached authenticated view to leak into
+  a different identity. Follow the current authenticated-cache restrictions.
+- Preserve exclusive disk-owner locking, bounded retention, restart behavior,
+  and reference-counted leaf lifetimes.
+- Browsing uses metadata only; previews fetch bounded slices/pages rather than
+  downloading whole containers. An upstream backend may still prefetch source
+  bytes according to its own semantics; distinguish this from client downloads.
+- Preserve immutable-source assumptions and explicit invalidation requirements.
+  No mutable-source TTL or automatic refresh protocol is introduced here.
+- Surface server slice-limit errors with guidance to request a smaller preview.
+- Do not imply all server-side table operations are available: cat2lite's
+  unsupported filters/indices must not be silently ignored or trigger an
+  unbounded local materialization.
+
+## 7. b2view integration
+
+- Route service recognition through shared Python-Blosc2 opening helpers.
+- Retain special direct-format handling only where needed for existing array/
+  table/group ownership behavior. Caterva2 interpretation takes precedence over
+  extensions in published dataset names.
+- Run discovery, group expansion, and previews in background work, keeping the
+  UI responsive during slow upstream metadata reads.
+- Show loading, empty-group, and retryable error states distinctly.
+- Support initial paths within a root or synthetic repository.
+- Check remote arrays, table paging/projection, scalar and multidimensional
+  previews, attrs, and plotting through existing data adapters.
+- Gate unsupported table actions consistently; do not offer operations that
+  require full remote downloads merely because a local CTable supports them.
+- Cancellation/closing the UI must release owners and transports cleanly.
+- Keep CLI cache options controlling the client cache, and label this clearly
+  in help. The user configures the shared server cache on cat2lite separately.
+
+## 8. Implementation milestones
+
+### M0 — Freeze contract and establish fixtures
+
+- Audit roots schemas, opener defaults/lazy behavior, authentication, and
+  existing descriptor/persistence constraints.
+- Finalize the explicit HTTP override and multi-root object design.
+- Add deterministic local HTTP fixtures for both conventional recursive
+  Caterva2 listings and catalog mount-boundary listings.
+- Record request counters and configurable failures/delays in those fixtures.
+
+Gate: a documented dispatch/return-type matrix and fixtures representing both
+protocol profiles; no network dependency for ordinary tests.
+
+### M1 — Root-marker URL shorthand
+
+- Implement reusable normalization and integrate it before file-format dispatch.
+- Preserve all existing URLPath and option semantics.
+- Add override support and documentation for literal `@` file URLs.
+
+Gate: equivalent strings and URLPath objects open the same groups/arrays/tables,
+including deployment prefixes and IPv6, without roots probing.
+
+### M2 — Lazy mount-aware RemoteStore traversal
+
+- Split metadata discovery from listing completion.
+- Implement direct descendant lookup, lazy expansion, memoization, and bounded
+  concurrent discovery.
+- Cover nested mounts and conventional recursively listed stores.
+
+Gate: a group omitted below the initial mount boundary can be expanded and
+read; healthy siblings remain usable after a failed expansion.
+
+### M3 — Base discovery and repository roots
+
+- Add bounded roots discovery and transport/error handling.
+- Implement single-root, empty-root, and multiple-root behavior.
+- Define repository cache and lifecycle rules; cover auth-separated identities.
+
+Gate: bare and prefixed server URLs browse correctly, while direct-file sources
+retain their dispatch and do not acquire extra roots requests.
+
+### M4 — b2view integration
+
+- Connect the shared opener, lazy tree expansion, and repository root object.
+- Update title/source display, capabilities, errors, and CLI help.
+- Add headless Textual tests against local servers.
+
+Gate: bare-server and explicit-root command forms browse groups and display
+bounded array/table previews without blocking the event loop.
+
+### M5 — Cross-project acceptance, documentation, and measurements
+
+- Run against a real debug cat2lite server serving a mixed `.catl` fixture.
+- Verify shared server-cache reuse across two independent clients and after
+  restart where the backend guarantees persistent reuse.
+- Update API docs, b2view guide, examples, and release notes.
+- Record startup/expansion request counts and representative cache evidence.
+
+Gate: all focused tests and relevant offline regressions pass; the use cases in
+section 1 work with documented limits and no new viewer executable.
+
+## 9. Regression and acceptance matrix
+
+### URL dispatch
+
+- HTTP/HTTPS, IPv4/IPv6, ports, trailing slash, deployment prefixes.
+- Root-marker group, array, table, and extension-bearing published names.
+- Multiple `@` components, encoded spaces, Unicode, encoded `@` root markers.
+- Query/userinfo/fragment ambiguity, traversal and double-decoding attempts.
+- Ordinary direct-file `@` paths via override; signed direct-file URLs.
+- Existing fsspec selectors, explicit URLPath, local paths, and non-HTTP inputs.
+- Cache-option forwarding and rejection of contradictory inputs.
+
+### Discovery and hierarchy
+
+- Valid zero/one/multiple roots; unexpected JSON/HTML; 404/401/403/5xx; timeout.
+- Prefix-preserving redirects and credential behavior.
+- Recursive listings, mount-boundary listings, empty groups, duplicate entries.
+- Direct access before parent expansion, repeated and concurrent expansion.
+- Node limits and per-group failures with subsequent successful retry.
+- No eager contact with unrelated remote mounts merely to open a repository.
+
+### Data and caching
+
+- Scalar/ND arrays, CTable row windows and projections, attrs/annotations.
+- No implicit full fetch for previews; correct handling of server byte limits.
+- none/memory/disk, identity equivalence, auth separation, close/reopen, restart.
+- Two processes with independent client caches reuse one server-side cache.
+  Use upstream byte/request counters and fixtures larger than backend prefetch
+  thresholds; do not confuse client-cache hits with server-cache hits.
+- Concurrent owner lifetimes and expected exclusive-lock failures where local
+  disk caches are deliberately shared without the supported sharing mode.
+
+### Viewer and compatibility
+
+- Headless tree expansion, starting path, empty/error states, preview paging,
+  cancellation, and clean shutdown under warnings-as-errors.
+- Existing direct HDF5/Zarr/B2Z/Parquet viewing remains functional.
+- Explicit URLPath callers retain return types and lazy=False behavior.
+- Existing Caterva2 and remote-store tests remain green.
+
+Run Python/build commands in the `blosc2` conda environment. Use targeted pytest
+runs during implementation, then the relevant offline opener/remote-store/
+remote-array/remote-table/b2view suites, Ruff on touched files, and the full
+offline suite for final validation. Follow actual test filenames discovered in
+the repository rather than assuming names in this plan are commands.
+
+## 10. Completion criteria and boundaries
+
+Complete when all proposed CLI forms work, equivalent Python opening works,
+catalog-mounted hierarchies expand lazily, multi-root behavior is documented,
+and cache reuse is demonstrated with measured upstream traffic.
+
+This work does not add a new viewer, a new remote protocol, write access,
+catalog parsing in Python-Blosc2, automatic cache invalidation, a server
+deployment/authentication system, or a guarantee that arbitrary remote formats
+support cheap random access. It reuses Caterva2's protocol and existing object
+adapters to make the shared-cache-server workflow convenient and predictable.
diff --git a/plans/caterva2-access-improvements2.md b/plans/caterva2-access-improvements2.md
new file mode 100644
index 000000000..6e8f1b929
--- /dev/null
+++ b/plans/caterva2-access-improvements2.md
@@ -0,0 +1,436 @@
+# Caterva2 ordinary-file access and previews in b2view
+
+Status: M0–M5 implemented and validated on `cat2-improvements` following explicit
+user authorization. The design below is retained as the delivery/acceptance record.
+It follows `plans/caterva2-access-improvements.md` and its completed URL discovery,
+lazy hierarchy browsing, and viewer integration work.
+
+## Implementation record
+
+- Notebook follow-up: passive nbformat-4 cell views for local/fsspec/Caterva2
+  files and local `.ipynb.b2` carriers. Markdown/code/raw cells and saved text
+  outputs share 64 KiB / 1,000 displayed lines and 100-cell limits; complete JSON
+  input is capped at 2 MiB. T toggles a bounded raw prefix. No Jupyter/kernel
+  dependency, execution, HTML/JavaScript, widget or embedded-media rendering.
+
+- Compressed local document follow-up: supported text/image/PDF names ending in
+  `.b2` are read-only mapped SChunk byte streams. Metadata stays payload-free;
+  text prefixes decode only intersecting chunks, images retain input/pixel caps,
+  and copies decode/write incrementally under the original filename. Lazy chunk
+  headers enforce 8 MiB compressed / 16 MiB decoded limits before payload copies.
+  Native arrays/serialized objects/references are not document carriers; plain
+  `.b2`/`.b2frame` dataset behavior is unchanged. Direct-fsspec carriers remain
+  separate work. No original file content is deserialized or executed.
+
+- Follow-up interface consistency: fallback panels have separate unavailable,
+  missing-dependency and failed-preview states, with a common status header,
+  reason and capability-aware action hints. Successful text previews share the
+  same hints (O only for supported external document types; T only for Markdown).
+  Read failures preserve file metadata and redact transport URLs/option values.
+  Local/fsspec ordinary-file support is delivered as a separate viewer-only
+  follow-up: direct regular-file inputs, shared passive previews/actions,
+  background I/O, known-size bounded reads and streamed atomic copies. Native
+  container formats retain their openers; unknown names get a small frame-magic
+  check. Generic directories, hierarchy export and new public RemoteFile
+  backends remain outside this follow-up. Backend caches are not Caterva2 caches.
+  Earlier local/fsspec exclusions in this delivery record are superseded for
+  direct ordinary-file inputs only.
+
+- User-requested directory follow-up: ordinary local/file-URL/fsspec directories
+  now expose immediate children lazily, with file previews/actions and dataset
+  containers mounted as browsable subtrees. Native dataset directories preserve
+  their opener. Parent traversal and local symlink following are refused.
+  Earlier generic-directory exclusions are superseded by this follow-up.
+
+- Follow-up UX decision: the extra trust checkbox is removed for all supported
+  documents, including images and PDFs. The explicit O action and destination
+  submission initiate external opening; signature/type restrictions and stale
+  request/shutdown guards remain. Earlier checkbox requirements below are
+  superseded by this user-requested decision.
+
+- M0: verified Caterva2 demo README transport: `api/chunk?nchunk=0` returns
+  a 552-byte compressed chunk that decompresses to the original 811 bytes;
+  `api/download` returns original Markdown bytes, not the `.b2` carrier.
+- API selected: `RemoteFile(RemoteObject)` with bounded `read_bytes`, streamed
+  original-byte `download`, shared owner/cache/auth lifecycle, and unsupported
+  reference persistence. Fixed-chunk SChunks are accepted, including typed byte
+  payloads; irregular layouts and oversized chunks are refused explicitly.
+- M1: recognition precedes array fallback; file handles participate in root and
+  direct-leaf opening. Existing exact-payload cache coordination/disk machinery
+  is reused with hash-separated file-chunk keys. Listing and metadata do not
+  fetch payload. Downloads stage on the destination filesystem and publish
+  atomically with no overwrite by default. Focused transport/access regression
+  validation: 62 tests passed in the blosc2 environment.
+- M2–M4: b2view recognizes file leaves, renders passive bounded text/Markdown
+  (64 KiB / 1,000 lines), toggles raw text, and decodes JPEG/PNG under independent
+  file/chunk/pixel limits. Image widgets reuse textual-image without matplotlib;
+  absent dependencies have download/open fallbacks. PDFs require no renderer:
+  D downloads original bytes and O prompts for destination and explicit trust
+  consent before a shell-free platform launch. All fetch/decode/download work is
+  backgrounded; downloads use independent handles and cancellation. Viewer/model
+  plus file transport regressions: 175 passed with TUI cases enabled. Live demo
+  checks: README renders; the JPEG decodes as 2034 × 1144 (bounded preview 1600 ×
+  900); PDF offers download/external opening without fetching content on selection.
+- M5/final review: added API/guide/installation/release documentation and the
+  `images` extra (Pillow/textual-image, no matplotlib; included by hires). Real
+  cat2lite native `.b2frame` file transport/download passes alongside existing
+  remote-format/shared-cache acceptance. Native cat2lite exposes this carrier
+  name; arbitrary ordinary-file publication/aliasing is not added to that server.
+- Review hardening: bounded network and cached chunk reads before decompression;
+  identity HTTP encoding, content-length/body caps, 10-second I/O timeouts and a
+  checked 20-second chunk deadline; independent transfer aliases prepared on a
+  background worker; no launcher after stale selection/session or shutdown.
+  Old unsupported file snapshots rediscover metadata. Added download publication
+  race, cancellation, empty-stream, corruption, cache eviction/refresh, auth,
+  missing image dependency, consent, and responsive slow-transfer regressions.
+- Final validation: default suite 10,670 passed, 38 skipped; focused offline
+  access/file/viewer/model suite 230 passed with headless TUI cases enabled;
+  opt-in live Caterva2 demo file downloads passed; both actual cat2lite acceptance
+  tests passed. Ruff/diff checks passed. HTML docs built using the existing
+  type-comment/notebook/generated-copy workarounds, with 764 wider autosummary/
+  theme/cross-reference warnings; the build is not warnings-clean.
+- Remaining constraints: fixed-chunk byte streams only; 8 MiB compressed / 16 MiB
+  decoded chunk caps apply to downloads too, so large single-chunk files need
+  server-side rechunking. No-overwrite downloads require hard-link-capable
+  destination filesystems. File reference persistence/hierarchy export is deferred.
+  MIME is a filename hint; binary/unknown files have no automatic preview. Image
+  decoder copies are not a whole-process memory limit. External launchers depend
+  on platform/GUI associations and are not a sandbox; tests mock launchers, never
+  open documents automatically. User-selected downloads are retained (no hidden
+  temporary external-viewer copies to manage). Local/fsspec regular-file support
+  and in-terminal PDF rendering remain explicit non-goals.
+- Live headless image integration also verified the real demo JPEG mounts an
+  `AutoImage` widget with the installed textual-image package (not a mocked
+  renderer). Explicit downloads remain bounded even when previews are unavailable;
+  no automatic raw-download endpoint fallback bypasses chunk safety limits.
+
+## 1. Goal and delivery order
+
+Browse ordinary files published by Caterva2-compatible services without treating
+them as unsupported array/table objects. Preserve the current hierarchy, root
+conventions, lazy discovery, authentication, and client/server cache separation.
+
+Deliver in this order:
+
+1. Ordinary-file metadata, bounded byte access, explicit downloads, and text/
+   Markdown previews.
+2. Image previews using optional image dependencies and terminal capabilities.
+3. PDF identification, download, and explicit external opening. Embedded PDF
+   rendering is optional follow-up work, not required for this plan's completion.
+
+Every file remains downloadable even if its format cannot be previewed. Do not
+make downloading an entire file an implicit prerequisite for listing a directory.
+
+Target viewer behavior:
+
+| Selection | Metadata/data behavior |
+| --- | --- |
+| `@public/examples/README.md` | File metadata and bounded Markdown/text preview |
+| `@public/examples/Wutujing-River.jpg` | File metadata and size-limited image preview, or a clear fallback |
+| `@public/examples/cat2cloud-brochure.pdf` | File metadata, PDF notice, download/external-open actions |
+| Unknown binary file | File metadata, preview-unavailable notice, download action |
+| Generic SChunk without ordinary-file semantics | Byte-stream metadata/download; no invented original-file type |
+
+Paths displayed for `@` roots have no leading slash. Internal browser selection
+paths remain unchanged. Local and direct fsspec regular-file support is outside
+this first delivery; do not accidentally intercept existing direct-format URLs.
+
+## 2. Current implementation and verified evidence
+
+Relevant code:
+
+- `src/blosc2/remote_store.py`: `_caterva2_kind`, discovery metadata, node lookup,
+  leaf handles, owner lifecycle, cache coordination, and `RemoteNode`.
+- `src/blosc2/schunk.py`: public `open` and Caterva2 leaf dispatch.
+- `src/blosc2/c2array.py`: existing authentication and info/fetch/chunk transport.
+- `src/blosc2/remote_object.py`: common remote-object contract.
+- `src/blosc2/remote_repository.py`: independently owned repository roots.
+- `src/blosc2/b2view/model.py`: object kinds, metadata, preview selection, leaf
+  lifetime, and display paths.
+- `src/blosc2/b2view/app.py`: worker requests, stale-result rejection, download
+  UI, and optional `textual-image` support currently used by plot screens.
+- `src/blosc2/b2view/render.py`: Rich metadata and data rendering.
+- `tests/test_remote_caterva2.py`, `tests/test_caterva2_access.py`, and
+  `tests/b2view/test_caterva2.py`: deterministic API/viewer fixtures.
+
+The current `_caterva2_kind` accepts groups, NDArrays, and CTables. Metadata
+without array shape/dtype or table schema consequently becomes `unsupported`.
+
+The following live info responses were inspected during planning at
+`https://cat2.cloud/demo/api/info/@public/examples/<name>`:
+
+| Name | Uncompressed bytes | Compressed bytes | Chunks |
+| --- | ---: | ---: | ---: |
+| `README.md` | 811 | 552 | 1 |
+| `Wutujing-River.jpg` | 724,498 | 723,929 | 1 |
+| `cat2cloud-brochure.pdf` | 44,155 | 36,889 | 1 |
+
+These responses expose SChunk fields (`nbytes`, `cbytes`, `chunksize`, `nchunks`,
+`cparams`, `vlmeta`) and server-internal `.b2` backing paths, not NDArray metadata.
+Do not display or construct download names from those internal filesystem paths.
+These observations establish metadata shape, not full transport compatibility:
+chunk and download semantics must still be verified before implementation.
+
+## 3. M0 — Protocol characterization and API decisions
+
+### Protocol matrix
+
+Create loopback fixtures for an ordinary-file SChunk, a generic byte SChunk, an
+NDArray, a table, an unknown object, and a group. Characterize:
+
+- Explicit kind values where available, plus legacy SChunk-shaped info responses.
+- `api/chunk` addressing and response framing for SChunks; final partial chunks,
+  empty streams, and variable-length/irregular layouts.
+- Whether bounded `api/fetch` selection uses byte positions or typed elements.
+- `api/download` semantics: original file bytes versus compressed Blosc frame,
+  suffix handling, response headers, streaming, and redirects.
+- Metadata preservation for MIME type, logical filename, user attrs, and catalog
+  annotations, without assuming those fields exist on legacy servers.
+- Compatibility with an actual Caterva2 deployment and cat2lite. cat2lite has
+  SChunk and download routes, but arbitrary native-file publication is not an
+  assumed existing capability. Record unsupported server combinations explicitly.
+
+Prefer chunk-based lazy reads if the protocol supports them reliably. Do not
+fall back to whole-file fetches silently for a bounded text preview. If a server
+cannot provide bounded work, expose metadata/download and explain the preview
+limitation, or require explicit consent for a capped full-file fetch.
+
+### Proposed public abstraction
+
+Use a `RemoteFile` (or a clearly documented byte-stream equivalent) inheriting
+`RemoteObject`, separate from array indexing and table operations. Resolve its
+final public name and API in M0 before implementation; audit existing SChunk and
+Proxy machinery for reusable transport/cache behavior.
+
+Proposed contract:
+
+- `source`, `attrs`, `traffic`, cache policy/allowance/usage, `close`, and context
+  management follow existing remote-object conventions.
+- `nbytes`, logical `name`, optional media type, and chunk/compressed-size metadata.
+- Explicit bounded `read_bytes(start, stop)` returning original uncompressed bytes.
+  Validate offsets and bounds; do not overload NDArray slicing semantics.
+- Streaming `download(destination, overwrite=False)` writes the original payload,
+  never an undocumented `.b2` carrier, with optional progress/cancellation hooks.
+- Downloading bytes is distinct from `save` of a remote reference. Reference
+  persistence/materialization is explicitly unsupported initially unless existing
+  artifact machinery can support it safely within scope.
+- No writable source operations. Closing a root/repository leaves returned file
+  handles usable, as with existing array/table handles.
+
+Direct service leaf opening via `blosc2.open("https://host/@public/README.md")`
+should return the same handle as hierarchy lookup. Preserve explicit URLPath
+defaults: define and test the nonlazy byte-stream case rather than silently
+changing all existing URLPath behavior.
+
+## 4. M1 — Discovery, byte access, cache, and download
+
+### Recognition and metadata
+
+- Recognize explicit file/SChunk kinds and strictly validated legacy SChunk
+  metadata. Classify NDArray/CTable metadata first to avoid confusing their
+  embedded chunk metadata with a file.
+- Validate nonnegative byte counts, chunk counts, and consistent layouts. Reject
+  booleans masquerading as counts, invalid compression metadata, and impossible
+  lengths. Do not assume every SChunk is a regular fixed-chunk byte stream.
+- Separate the transport kind from preview format. A `.jpg` suffix does not make
+  invalid metadata valid, nor guarantee that payload bytes are an image.
+- Retain source attrs, catalog attrs, and file transport metadata separately.
+- Preserve unknown metadata as an unsupported node with a useful diagnostic;
+  an invalid file must not hide healthy siblings.
+
+### Transport and resource ownership
+
+- Reuse bound auth, deployment-prefix handling, safe URL components, transport
+  pooling, and existing owner locks; never use a server-local `urlpath` as a URL.
+- Fetch only necessary compressed chunks; validate frame/chunk headers and output
+  length before allocating/decompressing. Charge actual response bytes once.
+- State preview transfer bounds separately from output bounds: a 64 KiB prefix
+  may require a much larger first chunk. Reject automatic preview work above
+  compressed/decompressed chunk limits instead of claiming it is bounded.
+- Streaming download uses bounded buffers/chunks and checks cancellation between
+  reads. Enforce response and decompression limits on the streamed path, not only
+  after loading a response into memory.
+- Never deserialize Python objects or execute embedded metadata to read a file.
+
+### Cache semantics
+
+- `MEMORY`: share the owner's existing retained-payload allowance across file,
+  array, and table leaves. Do not create a hidden per-file unlimited cache.
+- `NONE`: retain no payload between operations. Transient preview/download
+  buffers still have explicit limits and are not called persistent cache.
+- `DISK`: reuse source/auth identity, exclusive ownership, atomic publication,
+  and eviction conventions. Test reopened warm chunks and partial downloads.
+- Keep client caching distinct from gateway caching. Repository budgets remain
+  per root. Immutable-source assumptions and explicit invalidation remain.
+- Preview render buffers/decoded images have a separate, documented lifecycle
+  and limit; they are not silently counted as compressed chunk-cache bytes.
+
+### Safe downloads
+
+- Destination is chosen by the user. Sanitize suggested names from logical paths,
+  not Content-Disposition or server-local paths; reject traversal and separators.
+- No overwrite without confirmation; publish only a completed download. Use a
+  staging file on the destination filesystem and a no-clobber publication strategy
+  when overwrite is false, including concurrent-creation tests.
+- Failure/cancellation cleans up only this operation's staging file. Leave prior
+  destination contents untouched. Offer actionable permission/disk-full errors.
+- Download the original `.md`, `.jpg`, or `.pdf` bytes; expose compressed-carrier
+  export only as a separately named future operation if needed.
+
+Acceptance: list/inspect without payload reads; exact arbitrary byte ranges and
+streamed original-file downloads; mixed-leaf owner/cache/lifecycle tests pass.
+
+## 5. M2 — Text/Markdown previews and viewer actions
+
+Add a file node kind/icon, lightweight file metadata, and a preview result type
+separate from numerical array/table previews. Do not route files through grid
+paging, table filters, plotting, or scalar-array coercion.
+
+Suggested initial limits (finalize constants in M0 and document them):
+
+- Automatic text prefix: 64 KiB of original bytes, at most 1,000 displayed lines.
+- Automatic chunk work: at most 8 MiB compressed and 16 MiB decompressed per
+  chunk; higher limits require explicit user action, not silent escalation.
+- Download: streamed rather than held whole in RAM; explicit consent includes
+  known original size and destination. Unknown size gets a warning and progress
+  bytes without a fabricated percentage.
+
+Decode UTF-8/UTF-8 BOM first, with incremental decoding for a prefix that cuts a
+multibyte character. Detect binary/NUL-heavy content and avoid garbage previews.
+Invalid text gets an honest replacement/encoding notice; do not guess encodings
+aggressively. Escape terminal control/ANSI sequences, including OSC hyperlinks.
+
+For Markdown, use Textual's existing Markdown capabilities without new mandatory
+dependencies. Offer raw text fallback/toggle. Disable automatic embedded-image
+fetches, local file access, and external-link launching: a preview must not issue
+unrelated network requests. Mark truncated content, including unmatched fences;
+rendering errors fall back to safe text rather than breaking the viewer.
+
+Add explicit Download and Open externally actions. Audit existing keybindings
+before selecting keys; document them in help and expose enabled/disabled states.
+For PDF/unknown binary files, these actions are available even without a preview.
+
+All remote fetch/decode/download work runs outside the UI thread. Bind results
+to session, selection, and request IDs. Stale results must not change the visible
+preview or launch an external application. Show progress/errors, preserve healthy
+sibling browsing, and support retry. Shutdown releases all owned resources.
+
+Acceptance: README renders at its published path, large text is visibly truncated,
+binary files remain downloadable, and delayed/cancelled reads do not freeze or
+overwrite the current selection.
+
+## 6. M3 — Images
+
+Reuse Pillow and the optional `textual-image` integration; do not require
+matplotlib just to display an existing JPEG/PNG. Audit packaging extras so the
+installation hint accurately describes the minimum image dependencies.
+
+- Validate file signature/decoder result, not suffix alone. Start with JPEG/PNG;
+  do not promise arbitrary image formats or SVG/remote-resource rendering.
+- A normal image preview may require the complete original file. Suggested
+  automatic original-payload cap: 16 MiB, with independent chunk/transfer bounds.
+- Inspect dimensions before full decoding; suggested decoded-image budget:
+  64 MiB with an explicit pixel cap. Treat Pillow decompression-bomb warnings as
+  refusal and reject malformed/oversized inputs. Downsampling after decoding is
+  not a substitute for a predecode limit.
+- Correct EXIF orientation, aspect ratio, and resize-to-panel behavior. Show
+  dimensions and detected format. Bound animated-image handling to a first frame.
+- If dependencies or terminal protocols are unavailable, show metadata and a
+  fallback notice with Download/Open externally. Do not leave a blank panel.
+- Release image buffers/widgets on selection change and shutdown; no unbounded
+  decoded-thumbnail cache. Preserve worker/stale-result checks during resize.
+
+Acceptance: small JPEG/PNG fixtures display with image support enabled; missing
+dependency/protocol and unsafe-image cases have useful, tested fallbacks.
+
+## 7. M4 — PDFs and external opening
+
+PDF support in this delivery means recognition, metadata, and convenient safe
+download/opening, not a mandatory terminal PDF renderer. A PDF may be rendered
+externally even when the terminal cannot show images.
+
+- Identify PDF candidates from extension/media metadata and verify signature when
+  bytes are read. Do not invoke a PDF parser just to list or inspect file size.
+- Display "PDF preview unavailable; download or open externally" and actionable
+  controls. Missing renderer is not an unsupported-file error.
+- External opening is an explicit user action, never triggered by selection,
+  refresh, MIME detection, or restoring a session.
+- Prefer opening a completed local download, so bound service credentials never
+  appear in command-line URLs. Use platform launchers with argument arrays and
+  no shell (`open`, `xdg-open`, or the appropriate Windows API), check availability,
+  and use a safe absolute filename. Test launcher behavior with mocks only.
+- Confirm opening untrusted content. Never mark downloads executable or dispatch
+  unknown scripts/binaries to a launcher; external-open initially has a narrow
+  document/image allowlist. Download remains available for other file types.
+- Distinguish user-owned downloads from application-owned temporary copies.
+  External viewers can outlive b2view: document retention/cleanup and do not
+  delete a temporary file immediately after launch. Use a private session/temp
+  directory with cleanup of owned stale copies under an explicit policy.
+- Report no-GUI/headless/missing-launcher failures without losing the downloaded
+  file; show its location and allow the user to open it manually.
+
+Optional later milestone: PDF first-page thumbnails/text extraction using an
+opt-in backend, with page/pixel/time limits and untrusted-parser isolation where
+appropriate. This is not needed for M4 acceptance and must not become a mandatory
+dependency for ordinary-file access.
+
+## 8. M5 — Integration, documentation, and final review
+
+Extend offline fixtures with Markdown, invalid UTF-8, arbitrary binary data,
+JPEG/PNG, and PDF bytes, all transported as deterministic SChunks. Include empty,
+partial final chunk, typed/irregular SChunk, false suffix, and malformed responses.
+
+Acceptance matrix:
+
+| Area | Required checks |
+| --- | --- |
+| Discovery | Legacy/explicit kinds; groups/arrays/tables unchanged; no payload on listing |
+| Opening | String URL, URLPath, bare single/multi-root services, nested mounts; @ display paths |
+| Byte access | Empty/prefix/cross-chunk/end ranges; invalid bounds; output-length mismatch |
+| Cache | NONE/MEMORY/DISK; mixed-leaf budgets; eviction; reopened warm data; auth isolation |
+| Lifecycle | Children outlive parents; refresh/stale handles; cancellation and concurrency |
+| Text | Markdown/raw; UTF-8 boundary/BOM; binary/control characters; truncation; no linked fetches |
+| Images | JPEG/PNG; missing dependency/protocol; corruption; pixel/decode caps; resize/release |
+| Download | Original byte equality; overwrite race; unsafe names; cancelled/truncated response; disk failure |
+| External open | Explicit consent; no shell; launcher unavailable; no secrets; stale launch suppressed |
+| PDF | Useful nonrendering fallback; download/open without PDF dependency |
+| UI | Headless worker responsiveness; failed leaf isolation; actions/help and existing grids unaffected |
+
+Add opt-in real-service acceptance, not public-network dependency in the default
+suite. Where supported, verify two independent clients can reuse gateway payload
+cache; distinguish metadata rereads from payload rereads. Extend the actual
+cat2lite acceptance only for supported publication/protocol behavior, not an
+invented arbitrary-file server capability.
+
+Update public class/open documentation, remote-object guide, b2view guide,
+optional-extra installation instructions, and release notes. Include limits,
+download versus reference export, platform opening behavior, and fallbacks.
+
+Run Python/tests/build commands only in the `blosc2` conda environment. Run Ruff,
+focused access/viewer tests (including headless TUI cases), the default suite,
+and documentation checks. Preserve unrelated work and downloaded user files.
+
+Final review focuses on:
+
+1. Protocol assumptions validated on supported server versions.
+2. Peak-memory/transfer limits, especially one-chunk large files and images.
+3. Auth and path safety, unsafe content, and no implicit external side effects.
+4. Shared cache accounting and returned-handle lifetime.
+5. Worker cancellation, stale-result suppression, and safe atomic download.
+6. Missing-dependency/headless/platform fallbacks and remaining limitations.
+
+## 9. Known tradeoffs and non-goals
+
+- Compression granularity may make a tiny byte prefix expensive. Preview refusal
+  is preferable to an unbounded hidden download.
+- MIME/suffix hints are imperfect; content recognition is bounded and conservative.
+- Budgets bound retained compressed payload, not all decoder/transient RAM;
+  preview/decompression limits must be enforced independently.
+- External applications have their own security and lifecycle behavior; explicit
+  consent is not a sandbox. Credentials must never be passed to them.
+- No recursive directory download, archive extraction, file editing/upload,
+  automatic script execution, OCR, animated playback, or embedded browser.
+- No compulsory PDF renderer; download/external opening is a complete first
+  delivery for PDF and terminal-unrenderable supported documents.
+- Ordinary-file reference archives and full fsspec/local file-browser expansion
+  are separate future work unless M0 proves a small, safe existing integration.
diff --git a/plans/caterva2-demo-dataset-audit.md b/plans/caterva2-demo-dataset-audit.md
new file mode 100644
index 000000000..5fdfae937
--- /dev/null
+++ b/plans/caterva2-demo-dataset-audit.md
@@ -0,0 +1,140 @@
+# Caterva2 demo dataset audit
+
+Audit of `b2view https://cat2.cloud/demo`, 2026-10-03, in the `blosc2`
+environment. The live catalog has one root, `@public`. All paths below are
+relative to that root. This is a snapshot, not a guarantee about future server
+contents or installed codec versions.
+
+## Method and fixes
+
+- Enumerated `api/roots`, `api/list/@public`, and the HDF5 mount's own listing.
+- Inspected every listed leaf's metadata through `StoreBrowser.get_info` and
+  attempted a bounded preview (`max_rows=2`, `max_cols=2`). The legacy N-D
+  preview path uses up to 20 rows of one plane. Array reads remain chunk-granular;
+  no whole large array, notebook, PDF, or Parquet file was downloaded.
+- There are 32 top-level listing entries: 31 leaves and one HDF5 group. That
+  group exposes 11 more leaves: **42 leaves audited individually**.
+- Fixed `C2Array.dtype` to accept literal structured/subarray descriptors, as
+  native b2nd readers already do. Both NumPy `TypeError` and `ValueError` paths
+  matter. Parsing uses `ast.literal_eval`, not executable `eval`.
+- Fixed synthesized Caterva2 chunks for top-level subarray dtypes: NumPy expands
+  these into trailing dimensions, so chunk/block geometry must expand too when
+  repacking. The public source shape/dtype remain unchanged. Tests include
+  nonzero data, multiple chunks, partial edge chunks, block padding, and both
+  one- and two-dimensional outer shapes.
+- Five previously failing dtype cases now preview successfully: three native
+  structured arrays, HDF5 compound dtype, and HDF5 subarray dtype. The literal
+  directory name `unsupported` is not authoritative about current capabilities.
+
+## Every top-level entry
+
+| Path | Result after fixes | Analysis |
+| --- | --- | --- |
+| `examples/README.md` | Text/Markdown preview works | Ordinary SChunk byte stream. |
+| `examples/Wutujing-River.jpg` | Image preview works | JPEG; Pillow decodes and reduces the image. Terminal image layout was fixed separately. |
+| `examples/cat2cloud-brochure.pdf` | No inline preview, intentional | PDF download/external opening supported; no embedded PDF renderer. |
+| `examples/cube-1k-1k-1k.b2nd` | Numeric preview works | `int32`, shape `(1000,1000,1000)`; preview of one plane, not the entire volume. |
+| `examples/cubeA.b2nd` | Numeric preview works | `float64`, shape `(1,1000,1000)`. |
+| `examples/cubeB.b2nd` | Numeric preview works | `float64`, shape `(1,1000,1000)`. |
+| `examples/dir1/ds-2d.b2nd` | Numeric preview works | `uint16`, shape `(10,20)`; chunks need edge/block padding. |
+| `examples/dir1/ds-3d.b2nd` | Numeric preview works | `float32`, shape `(3,4,5)`. |
+| `examples/dir2/ds-4d.b2nd` | Complex preview works | `complex128`, shape `(2,3,4,5)`; no dtype parsing failure. |
+| `examples/ds-1d-b.b2nd` | Byte-string preview works | `S6`, shape `(1000,)`; values contain `foobar`. |
+| `examples/ds-1d-fields.b2nd` | **Fixed** | Structured integer/float/byte-string/bool dtype was a stringified field list. |
+| `examples/ds-1d.b2nd` | Numeric preview works | `int64`, shape `(1000,)`. |
+| `examples/ds-2d-fields.b2nd` | **Fixed** | Structured float32/float64 dtype; shape `(100,200)`. |
+| `examples/ds-hello.b2frame` | Downloadable, no automatic preview | Plain SChunk has no text suffix. A bounded read confirms repeated `Hello world!` bytes. It is not corrupt; content sniffing/raw SChunk previews are not implemented. |
+| `examples/ds-sc-attr.b2nd` | Scalar string preview works | Zero-dimensional `<U6`; value `foobar`. |
+| `examples/gaia-ly.b2nd` | Numeric preview works | `int64`, shape `(3,423920)`; chunk dimension exceeds the array extent, handled correctly. |
+| `examples/hdf5root-example.h5` | Group browsing works | Independently expanded HDF5 mount; all 11 children analyzed below. |
+| `examples/ironpill_nb.ipynb` | Downloadable, no automatic preview | JSON notebook; `.ipynb` is not among supported text-preview suffixes. No notebook execution or output rendering. |
+| `examples/kevlar-tomo.b2nd` | Numeric preview works | `uint16`, shape `(10,2167,2070)`; not an automatic tomography image viewer. |
+| `examples/lazyarray-large.png` | Image preview works | PNG; ordinary-file image path. |
+| `examples/lung-jpeg2000_10x.b2nd` | **Environment-dependent failure** | `uint16`, shape `(10,1248,2689)`, GROK codec 37. Local GROK plugin cannot load its C-Blosc2 library; see diagnosis below. |
+| `examples/mandel-jit-vs-nojit.ipynb` | Downloadable, no automatic preview | Notebook format intentionally not rendered/executed. |
+| `examples/mandelbrot-pure-dsl.ipynb` | Downloadable, no automatic preview | Same notebook limitation; independent metadata request succeeds. |
+| `examples/numbers_color.b2nd` | **Environment-dependent failure** | `uint8`, shape `(10,368,744,4)`, GROK codec 37. Same plugin-loading problem, not a JPEG ordinary file. |
+| `examples/numbers_gray.b2nd` | **Environment-dependent failure** | `uint8`, shape `(10,368,744)`, GROK codec 37. Same plugin-loading problem. |
+| `examples/sa-1M.b2nd` | **Fixed** | Million-record structured dtype with int32/float32/float64 fields. Only a prefix was previewed. |
+| `examples/slice-time.ipynb` | Downloadable, no automatic preview | Small notebook; size is not the obstacle, unsupported preview suffix is. |
+| `examples/tomo-guess-test.b2nd` | Numeric preview works | `uint16`, shape `(10,100,100)`. |
+| `large/chicago-taxi-flat.b2z` | **Server projection failure** | Recognized CTable; metadata/empty frame succeed. Every projected field fetch returns HTTP 500; unprojected `slice_=0:2` returns a valid 2-row, 14-column CTable. |
+| `large/chicago-taxi-flat.parquet` | No preview; download also exceeds current limits | Server publishes it as an opaque SChunk, not a Parquet table. Its 256 MiB decoded chunks exceed RemoteFile's 16 MiB decoded-chunk limit. No implicit alternate download bypass. |
+| `large/gaia-3d.b2nd` | Numeric preview works | `uint8`, shape `(20000,20000,20000)` (8 TB logical). Only chunks intersecting a tiny plane prefix were fetched. |
+| `large/slice-gaia-3d.ipynb` | Downloadable, no automatic preview | Notebook JSON, not an automatically rendered dataset. |
+
+## Every HDF5 mount leaf
+
+Paths in this table are relative to `examples/hdf5root-example.h5/`.
+
+| Path | Result after fixes | Analysis |
+| --- | --- | --- |
+| `arrays/1d-raw` | Numeric preview works | `uint8` one-dimensional data. |
+| `arrays/1ds-blosc2` | Byte-string preview works | Fixed-length `S6`, including `foobar`. |
+| `arrays/2d-gzip` | Complex preview works | Server converts HDF5 gzip-backed data to an NDArray slice. |
+| `arrays/2d-nochunks` | Complex preview works | Contiguous HDF5 storage is not a client blocker. |
+| `arrays/3d-blosc2` | Numeric preview works | Three-dimensional `uint8` data. |
+| `attrs` | Scalar preview works | Server exposes a scalar value, `0`. |
+| `scalar` | Scalar preview works | Value `123.456`. |
+| `string` | Scalar byte-string preview works | Value `Hello world!`. |
+| `unsupported/array-dtype` | **Fixed** | Descriptor `('<f8', (4,))`: literal parsing plus expanded synthesized chunk geometry. Outer shape `(10,)`; NumPy values have shape `(10,4)`. |
+| `unsupported/compound-dtype` | **Fixed** | Structured `u1`/`float64` fields, shape `(10,)`; same literal parsing flaw as the native structured datasets. |
+| `unsupported/empty` | Server-provided scalar preview works | Server advertises shape `()`, dtype `float64`, and returns `0.0`. This audit validates that representation, not the original HDF5 null/empty semantics; the path name alone cannot establish them. |
+
+## Remaining failures and limitations
+
+### GROK image-codec datasets (three independent leaves)
+
+All three metadata responses and small `api/fetch` requests succeed. Returned
+frames still advertise `Codec.GROK`; a server slice does not necessarily remove
+the client's codec dependency. Previewing a source chunk fails locally with
+`RuntimeError: Error while getting the buffer`. Plugin discovery shows the more
+specific cause:
+
+```
+blosc2_grok/libblosc2_grok.so:
+Library not loaded: @rpath/libblosc2.7.dylib
+```
+
+There are also fallback `ModuleNotFoundError: blosc2_grok` messages from plugin
+lookup subprocesses. Thus enum/codec registration alone does not prove the
+plugin can load. This is an installed binary/dependency mismatch, not a dtype
+or terminal bug. Fix the plugin's compatible shared-library installation, or
+have the server deliver slices with a built-in lossless codec. No environment
+installation, binary relinking, or deployment changes were made in this audit.
+
+### Taxi table projection (one leaf)
+
+Checked all 14 column names individually using `slice_=0:1&field=<name>`:
+each returns HTTP 500, including `company`, so this is not just dotted names.
+Without `field`, `slice_=0:2` returns 5,658 bytes that decode successfully.
+The viewer/RemoteCTable uses column projection and therefore encounters this
+server defect. A blanket retry without projection was not introduced: it would
+hide server errors and could multiply transfer sizes. The deployment needs a
+projection fix, or a deliberately bounded/capability-aware compatibility path.
+
+### Passive preview limitations (eight leaves)
+
+The PDF, plain `.b2frame`, five notebooks, and opaque Parquet file are recognized
+file handles, not unrecognized nodes. Unsupported preview does not mean broken
+discovery. PDF has explicit external opening; notebook/SChunk content can be
+downloaded and examined separately. Parquet is the exception: this particular
+server's chunk geometry exceeds byte-stream download limits too. Direct Python
+Blosc2 Parquet-source support does not imply a Caterva2 opaque file is a table.
+
+## Summary
+
+After the dtype/chunk fixes: **30 leaves successfully preview**, **8 have no
+automatic preview by current policy**, and **4 fail for external reasons**
+(3 local GROK-plugin loads, 1 server table-projection error). The HDF5 group's
+`unsupported` directory now has three readable server representations. These
+findings describe sampled reads, not full-data integrity or equality to original
+HDF5 sources.
+
+## Validation
+
+- Default suite: **10,685 passed, 38 skipped** in the `blosc2` environment.
+- Focused offline dtype/access/viewer/model tests: **234 passed**.
+- Opt-in live regression tests for all five repaired dtype leaves: **5 passed**.
+- Actual headless `B2ViewApp` sessions populated the data grid for each of those
+  five live leaves (including HDF5 subarray cells), not just model-only reads.
diff --git a/pyproject.toml b/pyproject.toml
index 66e29ab23..07664b095 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -58,9 +58,10 @@ hdf5 = ["h5py", "hdf5plugin"]
 # wasm32 (no TTY).  Install with `pip install "blosc2[tui]"`.  This also pulls
 # textual-plotext for the in-terminal braille plot (the 'p' key).
 tui = ["textual", "textual-plotext"]
+images = ["blosc2[tui]", "textual-image", "pillow"]
 # Adds the high-res 'h' view on top of [tui], rendering a real matplotlib image
 # (kitty/iTerm2/sixel, or half-cells elsewhere) — matplotlib is the heavy part.
-hires = ["blosc2[tui]", "textual-image", "matplotlib"]
+hires = ["blosc2[images]", "matplotlib"]
 # Read/write single-file containers through any fsspec URL (https://, s3://,
 # gs://, zip://, memory://...).  HTTP support is included; the other protocol
 # backends (s3fs, gcsfs, adlfs...) are the caller's install:
diff --git a/src/blosc2/__init__.py b/src/blosc2/__init__.py
index 75e61e82a..39008fd0b 100644
--- a/src/blosc2/__init__.py
+++ b/src/blosc2/__init__.py
@@ -627,6 +627,8 @@ def _raise(exc):
 from .remote_object import RemoteObject
 from .remote_array import RemoteMetadataMapping, RemoteArray
 from .remote_store import RemoteNode, RemoteStore
+from .remote_file import RemoteFile
+from .remote_repository import RemoteRepository
 from . import linalg
 from .linalg import tensordot, vecdot, permute_dims, matrix_transpose, matmul, transpose, diagonal, outer
 from .utils import linalg_funcs as linalg_funcs_list
@@ -931,6 +933,8 @@ def _raise(exc):
     "RemoteCTable",
     "RemoteNode",
     "RemoteStore",
+    "RemoteFile",
+    "RemoteRepository",
     "SChunk",
     "SimpleProxy",
     "SpecialValue",
diff --git a/src/blosc2/b2view/app.py b/src/blosc2/b2view/app.py
index e131b8494..47a2974ff 100644
--- a/src/blosc2/b2view/app.py
+++ b/src/blosc2/b2view/app.py
@@ -42,7 +42,7 @@
     PlotextPlot = None
 
 try:
-    # Auto-selects the best terminal image protocol (kitty/iTerm2/sixel),
+    # Auto-selects a supported terminal image protocol (kitty/sixel),
     # degrading to colored half-cells; used by the high-res 'h' plot view.
     from textual_image.widget import Image as TextualImage
 except ImportError:  # high-res view is optional
@@ -67,6 +67,7 @@
     "c2array": "▦",
     "ctable": "▤",
     "schunk": "▣",
+    "file": "📄",
     "unknown": "?",
 }
 
@@ -253,6 +254,7 @@ class HelpScreen(ModalScreen[None]):
             [
                 ("up / down", "move between nodes"),
                 ("enter", "select node (and expand groups)"),
+                ("f / ctrl+f", "filter discovered paths; optionally search recursively"),
             ],
         ),
         (
@@ -292,6 +294,15 @@ class HelpScreen(ModalScreen[None]):
                 ("escape", "close the plot (q quits b2view)"),
             ],
         ),
+        (
+            "Ordinary files",
+            [
+                ("D", "download original bytes to a chosen destination (no overwrite)"),
+                ("O", "download and open a document externally"),
+                ("T", "toggle raw text / Markdown or notebook rendering"),
+                ("escape", "cancel a file download or close its dialog"),
+            ],
+        ),
         (
             "Dim mode (N-D arrays)",
             [
@@ -1884,6 +1895,96 @@ def on_progress(downloaded: int, content_total: int | None) -> None:
         self.app.call_from_thread(self.dismiss, True)
 
 
+class FileTransferScreen(ModalScreen):
+    """Explicit destination and cancellable background original-byte download/open."""
+
+    CSS = """
+    FileTransferScreen { align: center middle; }
+    #file-transfer { width: 75; height: auto; border: thick $accent; padding: 1 2; background: $surface; }
+    """
+    BINDINGS: ClassVar = [("escape", "cancel", "Cancel")]
+
+    def __init__(self, file, *, external=False):
+        super().__init__()
+        self.file = file
+        self.external = external
+        self.cancelled = threading.Event()
+        self.started = False
+
+    def compose(self):
+        from pathlib import Path
+
+        from blosc2.b2view.file_preview import safe_text
+
+        name = safe_text(self.file.name).replace("\\", "_").replace("/", "_")
+        action = "Download and open externally" if self.external else "Download original file"
+        with Vertical(id="file-transfer"):
+            yield Static(
+                f"{action}: {name} ({self.file.nbytes:,} bytes)\n"
+                "Choose a destination; Enter starts. Escape cancels. Existing files are not overwritten.",
+                markup=False,
+            )
+            yield Input(value=str(Path.cwd() / name), id="file-destination")
+            yield Static("", id="file-status", markup=False)
+            yield ProgressBar(id="file-progress")
+
+    def on_mount(self):
+        self.origin = (self.app._remote_session, self.app._remote_request, self.app.selected_path)
+        self.query_one(Input).focus()
+
+    def on_input_submitted(self):
+        if self.started:
+            return
+        destination = self.query_one(Input).value
+        if not destination.strip():
+            return
+        self.started = True
+        self.query_one(Input).disabled = True
+        self._transfer(destination)
+
+    @work(thread=True, exit_on_error=False)
+    def _transfer(self, destination):
+        def progress(done, total):
+            self.app.call_from_thread(
+                self.query_one("#file-progress", ProgressBar).update, total=total, progress=done
+            )
+
+        try:
+            path = self.file.download(destination, progress=progress, cancel=self.cancelled.is_set)
+            # Navigation/refresh/shutdown must never launch an obsolete request.
+            current = (self.app._remote_session, self.app._remote_request, self.app.selected_path)
+            if (
+                not self.cancelled.is_set()
+                and self.external
+                and current == self.origin
+                and not self.app._closing
+            ):
+                from blosc2.b2view.file_preview import open_external
+
+                open_external(path)
+            if not self.cancelled.is_set():
+                self.app.call_from_thread(self._finished, f"Saved: {path}")
+        except Exception as error:
+            if not self.cancelled.is_set():
+                self.app.call_from_thread(
+                    self._finished, f"{self.app._error_message(error)}\nDestination: {destination}"
+                )
+        finally:
+            self.file.close()
+
+    def _finished(self, message):
+        self.query_one("#file-status", Static).update(message + "\nEscape closes this dialog.")
+
+    def action_cancel(self):
+        self.cancelled.set()
+        self.dismiss()
+
+    def on_unmount(self):
+        self.cancelled.set()
+        if not self.started:
+            self.file.close()
+
+
 class B2ViewHeader(Header):
     """App header that also shows the open bundle's filename, left of the title.
 
@@ -1980,6 +2081,7 @@ class B2ViewApp(App):
     #data-header { height: auto; padding: 0 1; }
     #data-table-row { height: 1fr; }
     #data-table { width: 1fr; height: 1fr; }
+    #file-image { height: auto; }
     #row-scrollbar { width: 1; height: 1fr; color: $primary; }
     #col-scrollbar { height: 1; width: 1fr; color: $primary; }
     #meta-scroll, #attrs-scroll, #data-scroll { height: 1fr; padding: 0 1; }
@@ -1999,12 +2101,13 @@ class B2ViewApp(App):
         Binding("g", "go_to_row", "Go to row", show=False),
         ("m", "maximize_panel", "Maximize"),
         ("r", "restore_or_refresh", "Restore/Refresh"),
+        ("ctrl+f", "tree_search", "Find"),
         Binding("t", "grid_row_top", "Top", show=False),
         Binding("b", "grid_row_bottom", "Bottom", show=False),
         Binding("s", "grid_col_start", "Row start", show=False),
         Binding("e", "grid_col_end", "Row end", show=False),
         Binding("c", "go_to_column", "Go to column", show=False),
-        Binding("f", "filter_rows", "Filter rows", show=False),
+        Binding("f", "find_or_filter", "Find / Filter rows", show=False),
         Binding("S", "sort_rows", "Sort by", show=False),
         Binding("R", "reverse_sort", "Reverse sort", show=False),
         Binding("G", "group_rows", "Group by", show=False),
@@ -2013,6 +2116,9 @@ class B2ViewApp(App):
         Binding("d", "dim_cycle", "Dim mode", show=False),
         Binding("enter", "dim_toggle_nav", "Toggle nav", show=False),
         Binding("escape", "dim_exit", "Exit dim mode", show=False),
+        Binding("D", "download_file", "Download file", show=False),
+        Binding("O", "open_file", "Open externally", show=False),
+        Binding("T", "raw_file", "Raw/Rendered", show=False),
     ]
 
     def __init__(
@@ -2029,8 +2135,11 @@ def __init__(
         storage_options: dict[str, Any] | None = None,
         cache_dir: str | None = None,
         max_cache_bytes: int | None = None,
+        remote_service: str = "auto",
     ):
         super().__init__()
+        self.register_theme(BLOSC2_THEME)
+        self.theme = "blosc2"
         self.sub_title = f"Python-Blosc2 {blosc2.__version__}"  # shown beside the title in the header
         if parse_container_url(urlpath)[2] in {"zarr", "hdf5"}:
             # Initialize before Textual captures stderr (fileno=-1), which
@@ -2043,6 +2152,7 @@ def __init__(
         self.storage_options = storage_options
         self.cache_dir = cache_dir
         self.max_cache_bytes = max_cache_bytes
+        self.remote_service = remote_service
         self.download_url = download_url  # when set, fetch urlpath before browsing
         self.info_url = info_url  # optional: metadata endpoint giving the size
         # Header label: the path as given on the CLI, or the @public-relative
@@ -2054,13 +2164,19 @@ def __init__(
         self.preview_rows = preview_rows
         self.preview_cols = preview_cols
         self.browser: StoreBrowser | None = None
+        self._source_opened = False
+        self.startup_error: str | None = None
         # Set when a remote browser is closed on its own thread (on_unmount);
         # lets teardown wait for the cache-dir lock to be released.
         self._browser_close_thread: threading.Thread | None = None
         self.loaded_paths: set[str] = set()
-        self._remote = is_fsspec_url(urlpath)
+        from blosc2.b2view.ordinary_file import ordinary_source
+
+        # Keep ordinary-file disk I/O and image decoding off the UI thread too.
+        self._remote = is_fsspec_url(urlpath) or ordinary_source(urlpath, remote_service)
         self._remote_session = 0
         self._remote_request = 0
+        self._file_raw = False
         self._remote_page_request = 0
         self._remote_page_pending = False
         self._remote_col_end = None
@@ -2079,6 +2195,9 @@ def __init__(
         self._active_dim = 0
         self._dim_mode = False
         self.loading_table_page = False
+        self._data_busy = False
+        self._data_busy_frame = 0
+        self._data_busy_timer = None
         # One-shot: apply the --panel start focus after the first update_panels,
         # once the data panel's display/contents have settled (see update_panels).
         self._apply_focus_on_next_update = False
@@ -2093,6 +2212,7 @@ def compose(self) -> ComposeResult:
         with Horizontal(id="main"):
             with B2ViewPanel(id="tree-pane") as tree_pane:
                 tree_pane.border_title = "tree"
+                tree_pane.border_subtitle = "?(help) | f(ind) | r(efresh)"
                 yield Tree("/", id="tree")
             with Vertical(id="right-pane"):
                 with Horizontal(id="top-row"):
@@ -2117,11 +2237,11 @@ def compose(self) -> ComposeResult:
                     yield Static("", id="col-scrollbar")
                     with VerticalScroll(id="data-scroll", can_focus=True):
                         yield Static("", id="preview")
+                        yield Vertical(id="file-image")
         yield Footer()
 
     def on_mount(self) -> None:
-        self.register_theme(BLOSC2_THEME)
-        self.theme = "blosc2"
+        self._data_busy_timer = self.set_interval(0.2, self._animate_data_busy, pause=True)
         if self.download_url:
             # Fetch the bundle first, then open it from _after_download.  The
             # message shows the @public-relative path (e.g. "large/foo.b2z"),
@@ -2153,21 +2273,28 @@ def _after_download(self, result: bool | str) -> None:
         if result is True:
             self._start_browsing()
         else:
-            self.exit(message=f"Download failed: {result}")
+            self._source_open_error(RuntimeError(f"Download failed: {result}"))
 
     def _start_browsing(self) -> None:
         """Open the bundle and populate the tree (the normal startup path)."""
         if self._remote:
+            self._set_data_busy(True)
             self.query_one("#metadata", Static).update("Loading remote container…")
             self._open_remote(self._remote_session, self.start_path)
             return
         browser_kwargs: dict[str, Any] = {
             "storage_options": self.storage_options,
             "cache_dir": self.cache_dir,
+            "remote_service": self.remote_service,
         }
         if self.max_cache_bytes is not None:
             browser_kwargs["max_cache_bytes"] = self.max_cache_bytes
-        self.browser = StoreBrowser(self.urlpath, **browser_kwargs)
+        try:
+            self.browser = StoreBrowser(self.urlpath, **browser_kwargs)
+        except Exception as exc:
+            self._source_open_error(exc)
+            return
+        self._source_opened = True
         self._populate_browser()
 
     def _populate_browser(self) -> None:
@@ -2217,7 +2344,7 @@ def _focus_panel_by_name(self, name: str) -> None:
         if getter is not None:
             getter().focus()
 
-    def _navigate_to_path(self, path: str) -> None:
+    def _navigate_to_path(self, path: str, *, focus_tree: bool = False) -> None:
         """Expand the tree and select the node at *path*."""
         tree = self.query_one("#tree", Tree)
         parts = [p for p in path.split("/") if p]
@@ -2246,6 +2373,8 @@ def _navigate_to_path(self, path: str) -> None:
         def _do_select():
             tree.select_node(node)
             tree.scroll_to_node(node)
+            if focus_tree:
+                tree.focus()
 
         self.call_after_refresh(_do_select)
 
@@ -2312,6 +2441,7 @@ def _open_remote(self, session, start_path):
             browser_kwargs: dict[str, Any] = {
                 "storage_options": self.storage_options,
                 "cache_dir": self.cache_dir,
+                "remote_service": self.remote_service,
             }
             if self.max_cache_bytes is not None:
                 browser_kwargs["max_cache_bytes"] = self.max_cache_bytes
@@ -2331,15 +2461,18 @@ def _open_remote(self, session, start_path):
                 browser.close()
         except Exception as exc:
             if browser is not None:
-                browser.close()
-            self._deliver_remote(session, self._remote_error, exc)
+                # Cleanup must not mask the opening failure and strand the UI.
+                with contextlib.suppress(Exception):
+                    browser.close()
+            self._deliver_remote(session, self._source_open_error, exc)
 
     def _finish_remote_open(self, browser, children):
         self.browser = browser
+        self._source_opened = True
         self._remote_children = children
         self._populate_browser()
 
-    def _remote_error(self, exc):
+    def _error_message(self, exc):
         # Transport exceptions can include signed URLs or credentials. Keep
         # source-specific limitations, but remove runtime URLs and option values.
         import re
@@ -2355,7 +2488,58 @@ def redact(options):
                     message = message.replace(value, "<option>")
 
         redact(self.storage_options or {})
-        self.query_one("#metadata", Static).update(f"{type(exc).__name__}: {message}")
+        from blosc2.b2view.file_preview import safe_text
+
+        return safe_text(f"{type(exc).__name__}: {message}")
+
+    def _source_open_error(self, exc):
+        if self._source_opened:
+            # A failed refresh must not turn a recoverable session into a
+            # startup failure. Leaf/list/page failures remain nonfatal too.
+            self._remote_error(exc)
+            return
+        import httpx
+        from rich.text import Text
+
+        if isinstance(exc, httpx.HTTPStatusError):
+            response = exc.response
+            reason = httpx.codes.get_reason_phrase(response.status_code)
+            detail = f"HTTP {response.status_code} {reason}."
+        else:
+            detail = self._error_message(exc)
+        self.startup_error = f"b2view: Could not open source: {detail}"
+        # Textual restores the terminal before printing this to its error
+        # console. Text prevents markup in exception strings being interpreted.
+        self.exit(return_code=1, message=Text(self.startup_error))
+
+    def _remote_error(self, exc):
+        if not self._remote_page_pending:
+            self._set_data_busy(False)
+        self.query_one("#metadata", Static).update(self._error_message(exc))
+
+    def _set_data_busy(self, busy):
+        """Animate only border text: never hide data or change pane geometry."""
+        self._data_busy = busy
+        if busy:
+            self._data_busy_frame = 0
+            self._animate_data_busy()
+            if self._data_busy_timer is not None:
+                self._data_busy_timer.resume()
+        else:
+            if self._data_busy_timer is not None:
+                self._data_busy_timer.pause()
+            self.query_one("#data-pane", B2ViewPanel).border_title = "data"
+
+    def _animate_data_busy(self):
+        if not self._data_busy:
+            return
+        from rich.text import Text
+
+        dots = ("·  ", "·· ", "···", " ··", "  ·", "   ")
+        title = Text("data")
+        title.append(" · loading " + dots[self._data_busy_frame % len(dots)], style="dim")
+        self.query_one("#data-pane", B2ViewPanel).border_title = title
+        self._data_busy_frame += 1
 
     def load_children(self, node) -> None:
         path = node.data or "/"
@@ -2407,6 +2591,43 @@ def on_tree_node_selected(self, event: Tree.NodeSelected) -> None:
         if event.node.allow_expand:
             self.load_children(event.node)
 
+    def action_tree_search(self):
+        if self.browser is None or not self.browser.is_tree:
+            self.notify("Search requires a directory or repository tree", severity="warning")
+            return
+        from blosc2.b2view.model import NodeInfo
+        from blosc2.b2view.search_screen import TreeSearchScreen
+
+        listings = dict(self._remote_children)
+        if not self._remote:
+            pending = [self.query_one("#tree", Tree).root]
+            while pending:
+                node = pending.pop()
+                pending.extend(node.children)
+                if node.data in self.loaded_paths:
+                    listings[node.data] = [
+                        NodeInfo(
+                            child.data,
+                            child.data.rsplit("/", 1)[-1],
+                            "group" if child.allow_expand else "unknown",
+                            child.allow_expand,
+                        )
+                        for child in node.children
+                    ]
+        browser, session = self.browser, self._remote_session
+        screen = TreeSearchScreen(browser, listings, session)
+
+        def reveal(selection):
+            if self.browser is not browser or self._remote_session != session:
+                return
+            # Retain discovered listings without changing the main tree's
+            # expansion/selection when the dialog is simply closed.
+            self._remote_children.update(screen.listings)
+            if selection is not None:
+                self._navigate_to_path(selection.path, focus_tree=True)
+
+        self.push_screen(screen, reveal)
+
     def update_panels(self, path: str) -> None:
         if self.browser is None:
             return
@@ -2417,6 +2638,7 @@ def update_panels(self, path: str) -> None:
         self._remote_request += 1
         self._remote_page_request += 1
         if self._remote:
+            self._set_data_busy(True)
             self.table_page = self.table_buffer = None
             self.query_one("#metadata", Static).update("Loading node…")
             self.query_one("#data-table", DataTable).clear(columns=True)
@@ -2433,9 +2655,14 @@ def _read_remote_info(self, session, request, browser, path):
                 info = browser.get_info(path)
                 data = None
                 if info.kind == "unsupported":
-                    data = {"message": info.metadata.get("preview", "Preview unavailable")}
+                    data = {
+                        "preview_status": "Preview unavailable",
+                        "message": info.metadata.get("preview", "Unsupported object type."),
+                    }
                 elif info.kind not in {"group", "remote_store"} and not self._uses_grid_preview(info):
-                    data = browser.preview(path, max_rows=self.preview_rows, max_cols=self.preview_cols)
+                    data = browser.preview(
+                        path, max_rows=self.preview_rows, max_cols=self.preview_cols, raw_text=self._file_raw
+                    )
             self._deliver_remote(session, self._finish_remote_info, request, path, info, data, None)
         except Exception as exc:
             self._deliver_remote(session, self._finish_remote_info, request, path, None, None, exc)
@@ -2443,6 +2670,7 @@ def _read_remote_info(self, session, request, browser, path):
     def _finish_remote_info(self, request, path, info, data, error):
         if request != self._remote_request:
             return
+        self._set_data_busy(False)
         if error is not None:
             self._remote_error(error)
             return
@@ -2455,6 +2683,7 @@ def _render_panels(self, path, info=None, remote_data=None):
         data_table_row = self.query_one("#data-table-row", Horizontal)
         data_scroll = self.query_one("#data-scroll", VerticalScroll)
         preview = self.query_one("#preview", Static)
+        self.run_worker(self._show_file_image(path, remote_data), exclusive=True, group="file-image")
         attrs_pane = self.query_one("#attrs-pane", B2ViewPanel)
         attrs_widget = self.query_one("#attrs-data", Static)
         try:
@@ -2474,7 +2703,7 @@ def _render_panels(self, path, info=None, remote_data=None):
                 data_scroll.display = True
                 self.query_one("#col-scrollbar", Static).display = False
                 data_header.update("")
-                preview.update("Group node; select an array or table to preview.")
+                preview.update("Group node; select an array, table or file to preview.")
                 self._update_attrs(attrs_pane, attrs_widget, path)
             else:
                 if self._uses_grid_preview(info):
@@ -2502,6 +2731,8 @@ def _render_panels(self, path, info=None, remote_data=None):
                     self._update_data_header(data)
                     self.call_after_refresh(self._ensure_viewport_consistent)
                 else:
+                    if isinstance(data, dict) and "preview_error" in data:
+                        data = {**data, "message": self._error_message(data["preview_error"])}
                     header, body = make_preview_renderables(data)
                     data_header.display = header is not None
                     data_table_row.display = False
@@ -2528,6 +2759,124 @@ def _render_panels(self, path, info=None, remote_data=None):
             self._apply_focus_on_next_update = False
             self.call_after_refresh(self._apply_start_focus)
 
+    async def _show_file_image(self, path, data):
+        body = self.query_one("#file-image", Vertical)
+        await body.remove_children()
+        if path != self.selected_path or not isinstance(data, dict):
+            return
+        if "notebook_cells" in data:
+            await self._show_notebook_images(body, data)
+            return
+        if "file_image" not in data:
+            return
+        if TextualImage is None:
+            self._show_image_fallback(
+                "Missing dependency", "Terminal image preview needs textual-image. Install blosc2[images]."
+            )
+            return
+        try:
+            image = TextualImage(data["file_image"])
+            # The default fractional height collapses inside an auto-height
+            # container. Let the widget derive its height from the image ratio.
+            image.styles.width = "auto"
+            image.styles.height = "auto"
+            await body.mount(image)
+        except Exception as error:
+            self._show_image_fallback("Preview failed", self._error_message(error))
+
+    async def _show_notebook_images(self, body, data):
+        if not any(cell.get("images") for cell in data["notebook_cells"]):
+            return
+        if TextualImage is None:
+            await body.mount(Static("Saved plots need textual-image. Install blosc2[images]."))
+            return
+        from blosc2.b2view.render import notebook_cell_renderable
+
+        widgets = []
+        for cell in data["notebook_cells"]:
+            widgets.append(Static(notebook_cell_renderable(cell, data["language"])))
+            for payload in cell.get("images", []):
+                try:
+                    image = TextualImage(payload)
+                    image.styles.width = "auto"
+                    image.styles.height = "auto"
+                    widgets.append(image)
+                except Exception:
+                    widgets.append(Static("Saved plot could not be displayed."))
+        await body.mount(*widgets)
+        self.query_one("#preview", Static).update("")
+
+    def _show_image_fallback(self, status, reason):
+        from blosc2.b2view.file_preview import file_fallback
+
+        header, body = make_preview_renderables(file_fallback("image.png", status, reason))
+        self.query_one("#data-header", Static).display = True
+        self.query_one("#data-header", Static).update(header)
+        self.query_one("#preview", Static).update(body)
+
+    def _file_action(self, external=False):
+        if self.browser is None or self._selected_info is None or self._selected_info.kind != "file":
+            self.notify("Select an ordinary file first", severity="warning")
+            return
+        self._prepare_file_transfer(
+            self._remote_session, self._remote_request, self.browser, self.selected_path, external
+        )
+
+    @work(thread=True, exit_on_error=False)
+    def _prepare_file_transfer(self, session, request, browser, path, external):
+        from pathlib import PurePosixPath
+
+        from blosc2.b2view.file_preview import EXTERNAL_SUFFIXES
+        from blosc2.b2view.ordinary_file import OrdinaryFile
+
+        alias = None
+        try:
+            with browser.io_lock:
+                if session != self._remote_session or request != self._remote_request:
+                    return
+                obj = browser._get_object(path)
+                if not isinstance(obj, (blosc2.RemoteFile, OrdinaryFile)):
+                    return
+                if external and PurePosixPath(obj.name).suffix.lower() not in EXTERNAL_SUFFIXES:
+                    raise ValueError(
+                        "External opening is restricted to document/image files; use D to download"
+                    )
+                alias = (
+                    obj.alias()
+                    if isinstance(obj, OrdinaryFile)
+                    else blosc2.RemoteFile._from_owner(obj._owner, obj.path)
+                )
+            delivered = self._deliver_remote(
+                session, self._finish_file_transfer, request, path, alias, external, None
+            )
+            if not delivered:
+                alias.close()
+        except Exception as error:
+            if alias is not None:
+                alias.close()
+            self._deliver_remote(session, self._finish_file_transfer, request, path, None, external, error)
+
+    def _finish_file_transfer(self, request, path, file, external, error):
+        if request != self._remote_request or path != self.selected_path:
+            if file is not None:
+                file.close()
+            return
+        if error is not None:
+            self.notify(str(error), severity="warning")
+            return
+        self.push_screen(FileTransferScreen(file, external=external))
+
+    def action_download_file(self):
+        self._file_action()
+
+    def action_open_file(self):
+        self._file_action(external=True)
+
+    def action_raw_file(self):
+        if self._selected_info is not None and self._selected_info.kind == "file":
+            self._file_raw = not self._file_raw
+            self.update_panels(self.selected_path)
+
     @staticmethod
     def _format_attr_value(value: Any) -> str:
         """Format an attribute value for display."""
@@ -2776,20 +3125,19 @@ def _load_table_page(self, path: str, start: int) -> dict:
             self._remote_page_request += 1
             request = self._remote_page_request
             self._remote_page_pending = True
+            self._set_data_busy(True)
             if layout is not None:
                 self._sync_layout_scroll(start, layout)
-            options = {"max_rows": page_size * 10, "max_cols": self._candidate_max_cols()}
-            if layout is not None:
-                options["layout"] = copy.deepcopy(layout)
-            else:
-                options.update(start=start, stop=start + page_size * 10, col_start=self.grid_col_start)
             column_end, self._remote_col_end = self._remote_col_end, None
-            if column_end is not None:
-                options["max_cols"] = column_end - self.grid_col_start
-            self._read_remote_page(
-                self._remote_session, request, self.browser, path, start, options, column_end
+            # Showing the grid changes its geometry. Size the request after
+            # that layout pass, rather than fetching a provisional viewport.
+            self.call_after_refresh(
+                self._start_remote_page, self._remote_session, request, path, start, column_end
             )
-            self.query_one("#metadata", Static).update("Loading array page…")
+            # Keep the last rendered page and metadata visible during paging
+            # and resize requests. Only a new node needs an empty placeholder.
+            if self.table_page is not None and self.table_page["columns"]:
+                return self.table_page
             shape = tuple(self._selected_info.metadata.get("shape", ()))
             row_dim = layout.navigable_dims[0] if layout and layout.navigable_dims else None
             nrows = layout.total_for_dim(row_dim) if row_dim is not None else (shape[0] if shape else 1)
@@ -2831,6 +3179,20 @@ def _load_table_page(self, path: str, start: int) -> dict:
             )
         return self._store_table_buffer(data, start, page_size)
 
+    def _start_remote_page(self, session, request, path, start, column_end):
+        if session != self._remote_session or request != self._remote_page_request or self.browser is None:
+            return
+        page_size = self._table_page_size()
+        options = {"max_rows": page_size * 10, "max_cols": self._candidate_max_cols()}
+        if self._data_layout is not None:
+            self._sync_layout_scroll(start, self._data_layout)
+            options["layout"] = copy.deepcopy(self._data_layout)
+        else:
+            options.update(start=start, stop=start + page_size * 10, col_start=self.grid_col_start)
+        if column_end is not None:
+            options["max_cols"] = column_end - self.grid_col_start
+        self._read_remote_page(session, request, self.browser, path, start, options, column_end)
+
     @work(thread=True, exit_on_error=False)
     def _read_remote_page(self, session, request, browser, path, start, options, column_end):
         try:
@@ -2846,6 +3208,7 @@ def _finish_remote_page(self, request, start, data, error, column_end):
         if request != self._remote_page_request:
             return
         self._remote_page_pending = False
+        self._set_data_busy(False)
         if error is not None:
             self._remote_error(error)
             return
@@ -2952,6 +3315,9 @@ def _slice_table_buffer(self, start: int, page_size: int) -> dict:
 
     def _update_data_table(self, data: dict, *, cursor_row: int = 0, cursor_col: int | None = None) -> None:
         """Refresh the data grid; *cursor_col* None keeps the current column."""
+        if self._remote_page_pending and data is self.table_page and data["columns"]:
+            self.loading_table_page = True
+            return
         table = self.query_one("#data-table", DataTable)
         if cursor_col is None:
             cursor_col = table.cursor_column
@@ -3466,6 +3832,13 @@ def _view_plot_range(self, span: tuple[int, int] | None) -> None:
     def _enter_row_window(self, start: int, stop: int, *, backend: str) -> None:
         """Replace the grid with a locked [start:stop] window (in place)."""
         if backend == "ctable":
+            if self._remote:
+                self._remote_request += 1
+                self._prepare_remote_window(
+                    self._remote_session, self._remote_request, self.browser, self.selected_path, start, stop
+                )
+                self.query_one("#metadata", Static).update("Loading row window…")
+                return
             try:
                 self.browser.set_row_window(self.selected_path, start, stop)
             except Exception as exc:  # pragma: no cover - defensive
@@ -3479,6 +3852,32 @@ def _enter_row_window(self, start: int, stop: int, *, backend: str) -> None:
         self._reload_row_window(0)
         self.notify(f"Locked to rows {start}:{stop} · esc to unlock")
 
+    @work(thread=True, exit_on_error=False)
+    def _prepare_remote_window(self, session, request, browser, path, start, stop):
+        try:
+            with browser.io_lock:
+                if session != self._remote_session or request != self._remote_request:
+                    return
+                view = browser.prepare_row_window(path, start, stop)
+            self._deliver_remote(
+                session, self._finish_remote_window, request, browser, path, start, stop, view, None
+            )
+        except Exception as exc:
+            self._deliver_remote(
+                session, self._finish_remote_window, request, browser, path, start, stop, None, exc
+            )
+
+    def _finish_remote_window(self, request, browser, path, start, stop, view, error):
+        if request != self._remote_request or path != self.selected_path or browser is not self.browser:
+            return
+        if error is not None:
+            self._remote_error(error)
+            return
+        browser.install_row_window(path, view)
+        self.row_window = (start, stop)
+        self._reload_row_window(0)
+        self.notify(f"Locked to rows {start}:{stop} · esc to unlock")
+
     def _exit_row_window(self) -> None:
         """Unlock the row window and restore the full grid."""
         if self.row_window is None:
@@ -3518,12 +3917,24 @@ def action_go_to_column(self) -> None:
             screen = GoToColumnScreen(ncols=page["ncols"], current=current, names=None)
         self.push_screen(screen, self._go_to_column)
 
+    def action_find_or_filter(self) -> None:
+        if self.query_one("#tree", Tree).has_focus:
+            self.action_tree_search()
+        else:
+            self.action_filter_rows()
+
     def action_filter_rows(self) -> None:
         if not self._in_data_grid():
             return
         if self.table_page.get("source_kind") != "ctable":
             self.notify("Filtering is only supported for CTable nodes", severity="warning")
             return
+        if not self.browser.supports_table_transforms(self.selected_path):
+            self.notify(
+                "Filtering remote tables is unsupported; materialize a bounded selection first",
+                severity="warning",
+            )
+            return
         if self.browser.get_group(self.selected_path):
             self.notify("Ungroup (Esc) before filtering", severity="warning")
             return
@@ -3536,6 +3947,12 @@ def action_sort_rows(self) -> None:
         if self.table_page.get("source_kind") != "ctable":
             self.notify("Sorting is only supported for CTable nodes", severity="warning")
             return
+        if not self.browser.supports_table_transforms(self.selected_path):
+            self.notify(
+                "Sorting remote tables is unsupported; materialize a bounded selection first",
+                severity="warning",
+            )
+            return
         if self.browser.get_group(self.selected_path):
             # Sort the (tiny) grouped result by any of its columns — key or aggregate.
             columns = self.browser.column_names(self.selected_path) or []
@@ -3627,6 +4044,12 @@ def action_group_rows(self) -> None:
         if self.table_page.get("source_kind") != "ctable":
             self.notify("Grouping is only supported for CTable nodes", severity="warning")
             return
+        if not self.browser.supports_table_transforms(self.selected_path):
+            self.notify(
+                "Grouping remote tables is unsupported; materialize a bounded selection first",
+                severity="warning",
+            )
+            return
         keys = self.browser.group_key_columns(self.selected_path)
         if not keys:
             self.notify("No dictionary/numeric columns to group by", severity="warning")
@@ -3820,6 +4243,8 @@ def _ensure_viewport_consistent(self) -> None:
         determine the window.  Later paging then uses the settled viewport
         sizes, so the windows would drift unless we reload once here.
         """
+        if self._remote_page_pending:
+            return
         page = self.table_page
         if self._remote and page is not None and not page["columns"]:
             return
@@ -3845,7 +4270,10 @@ def _reload_table_for_current_viewport(self) -> None:
         current = self.table_page["start"] + self.query_one("#data-table", DataTable).cursor_row
         page_size = self._table_page_size()
         start = (current // page_size) * page_size
-        self.table_buffer = None
+        # Height-only changes can be served from the prefetched row buffer.
+        # A width change needs new column fitting (and possibly more columns).
+        if self.table_page.get("viewport_width") != self._data_table_width():
+            self.table_buffer = None
         data = self._load_table_page(self.selected_path, start)
         self._update_data_table(data, cursor_row=current - data["start"])
         self._update_data_header(data)
@@ -3896,6 +4324,7 @@ def action_refresh(self) -> None:
             return
         tree = self.query_one("#tree", Tree)
         node = tree.cursor_node or tree.root
+        self._remote_children.clear()
         self.loaded_paths.discard(node.data or "/")
         node.remove_children()
         self.load_children(node)
diff --git a/src/blosc2/b2view/cli.py b/src/blosc2/b2view/cli.py
index a12d67e36..6ebd24fb0 100644
--- a/src/blosc2/b2view/cli.py
+++ b/src/blosc2/b2view/cli.py
@@ -40,7 +40,15 @@ def resolve_source(
 
 def build_parser() -> argparse.ArgumentParser:
     parser = argparse.ArgumentParser(description="Browse a Blosc2 bundle or array in the terminal.")
-    parser.add_argument("urlpath", nargs="?", default=None, help="Local path or remote array URL")
+    parser.add_argument(
+        "urlpath", nargs="?", default=None, help="Local path, remote data URL, or Caterva2 server/root URL"
+    )
+    parser.add_argument(
+        "--remote-service",
+        choices=["auto", "caterva2", "fsspec"],
+        default="auto",
+        help="Remote access backend (fsspec bypasses Caterva2 recognition)",
+    )
     parser.add_argument("path", nargs="?", default="/", help="Optional starting path inside the bundle")
     parser.add_argument("--profile", help="S3 credential profile")
     parser.add_argument("--endpoint-url", help="S3 endpoint URL")
@@ -58,7 +66,7 @@ def build_parser() -> argparse.ArgumentParser:
     parser.add_argument(
         "--cache-dir",
         metavar="DIR",
-        help="Directory for persistent disk caching of remote stores and arrays",
+        help="Client-side disk cache directory (independent of the server cache; repository budgets are per root)",
     )
     parser.add_argument(
         "--max-cache-bytes",
@@ -130,6 +138,7 @@ def main(argv: list[str] | None = None) -> int:
         info_url=info_url,
         cache_dir=args.cache_dir,
         max_cache_bytes=args.max_cache_bytes,
+        remote_service=args.remote_service,
         storage_options={
             key: value
             for key, value in {"profile": args.profile, "endpoint_url": args.endpoint_url}.items()
@@ -138,7 +147,7 @@ def main(argv: list[str] | None = None) -> int:
         or None,
     )
     app.run(mouse=args.mouse)
-    return 0
+    return app.return_code or 0
 
 
 if __name__ == "__main__":
diff --git a/src/blosc2/b2view/compressed_file.py b/src/blosc2/b2view/compressed_file.py
new file mode 100644
index 000000000..a6e27d57a
--- /dev/null
+++ b/src/blosc2/b2view/compressed_file.py
@@ -0,0 +1,222 @@
+"""Lazy local/fsspec document carriers; never deserialize the original payload."""
+
+import mimetypes
+import os
+import struct
+from pathlib import PurePosixPath
+from urllib.parse import unquote, urlsplit
+
+import blosc2
+from blosc2 import blosc2_ext
+from blosc2.b2view.file_preview import IMAGE_SUFFIXES, TEXT_SUFFIXES
+from blosc2.b2view.ordinary_file import MAX_READ_BYTES, OrdinaryFile, local_path, ordinary_filesystem
+from blosc2.core import find_url_separator, is_fsspec_url, parse_container_url
+from blosc2.deserialization import set_deserialize
+from blosc2.remote_file import MAX_COMPRESSED_CHUNK, MAX_DECODED_CHUNK
+
+
+def _carrier_name(source):
+    separator = find_url_separator(source)
+    member = source if separator == -1 else source[:separator]
+    if "://" in member:
+        parsed = urlsplit(member)
+        member = unquote(parsed.path or parsed.netloc)
+    return PurePosixPath(member).name
+
+
+def compressed_document(source):
+    """Recognize supported-document suffixes followed by .b2, not bare .b2."""
+    source = os.fspath(source)
+    _, dataset, source_format = parse_container_url(source)
+    if dataset is not None or source_format is not None:
+        return False
+    name = _carrier_name(source)
+    return name.lower().endswith(".b2") and PurePosixPath(name[:-3]).suffix.lower() in (
+        TEXT_SUFFIXES | IMAGE_SUFFIXES | {".pdf"}
+    )
+
+
+class CompressedFile(OrdinaryFile):
+    """Original document bytes in a read-only mapped or range-backed SChunk."""
+
+    def __init__(self, source, storage_options=None):
+        self._closed = False
+        self.fs = None
+        self.source_path = os.fspath(source)
+        self.storage_options = storage_options
+        if is_fsspec_url(self.source_path):
+            from blosc2.proxy_source import ByteRangeSChunkSource
+
+            self.fs, self.path = ordinary_filesystem(self.source_path, storage_options)
+            info = self.fs.info(self.path)
+            if info.get("type") != "file" or type(info.get("size")) is not int:
+                raise ValueError("Document carrier requires a regular file with a known size")
+            self._frame_size = info["size"]
+            self._schunk = ByteRangeSChunkSource(self._range, self._frame_size)
+            self.carrier = _carrier_name(self.source_path)
+        else:
+            self.path = local_path(self.source_path).absolute()
+            self._schunk = self._open_local()
+            self.carrier = self.path.name
+        self._set_metadata()
+
+    def _open_local(self):
+        # Open only a native SChunk: do not invoke public-open dispatch for
+        # persistent expressions, object serialization or remote references.
+        self._schunk = blosc2_ext.open(str(self.path), "r", 0, mmap_mode="r")
+        if not isinstance(self._schunk, blosc2.SChunk):
+            self._schunk = None
+            raise ValueError("Document carrier must be an SChunk byte stream, not an array or table")
+        set_deserialize(self._schunk, "safe")
+        return self._schunk
+
+    def _set_metadata(self):
+        structural = {
+            "b2tree",
+            "b2o",
+            "listarray",
+            "vlarray",
+            "batcharray",
+            "LazyArray",
+            "proxy-source",
+            "b2remote_array",
+            "b2remote_ctable",
+            "b2remote_store",
+        }
+        if structural.intersection(self._schunk.meta):
+            self._schunk = None
+            raise ValueError("Document carrier must be a plain SChunk byte stream, not a serialized object")
+        self.nbytes = self._schunk.nbytes
+        self.cbytes = self._schunk.cbytes
+        self.chunksize = self._schunk.chunksize
+        if not self.nbytes and self.chunksize < 0:
+            self.chunksize = 0
+        self.nchunks = self._schunk.nchunks
+        expected = (
+            (self.nbytes + self.chunksize - 1) // self.chunksize if self.nbytes and self.chunksize > 0 else 0
+        )
+        if (self.nbytes and self.chunksize <= 0) or self.nchunks != expected:
+            self._schunk = None
+            raise ValueError("Document carrier requires a fixed-chunk byte stream")
+        self.name = self.carrier[:-3]
+        self.media_type = mimetypes.guess_type(self.name)[0]
+
+    def alias(self):
+        self._check_open()
+        # Transfers have independent mappings and native lifetimes.
+        return CompressedFile(self.source_path, self.storage_options)
+
+    def _range(self, offset, size):
+        self._check_open()
+        if not 0 <= offset <= self._frame_size - size or not 0 <= size <= MAX_COMPRESSED_CHUNK:
+            raise ValueError("Document byte range exceeds bounds")
+        if urlsplit(self.source_path).scheme in {"http", "https"}:
+            from fsspec.asyn import sync
+
+            return sync(self.fs.loop, _http_range, self.fs, self.path, offset, size, self._frame_size)
+        with self.fs.open(self.path, "rb", cache_type="none") as stream:
+            stream.seek(offset)
+            data = stream.read(size)
+        if len(data) != size:
+            raise ValueError("Document changed or returned a short range")
+        return data
+
+    def _chunk(self, index):
+        self._check_open()
+        # Lazy chunk headers expose lengths without copying/decompressing the
+        # stored payload. Check budgets before fetching the actual chunk.
+        header = self._schunk.get_lazychunk(index)
+        if len(header) < 16:
+            raise ValueError("Invalid document chunk header")
+        nbytes, _, cbytes = struct.unpack_from("<III", header, 4)
+        if nbytes > MAX_DECODED_CHUNK:
+            raise ValueError(
+                f"Document chunk exceeds {MAX_DECODED_CHUNK >> 20} MiB decoded limit; rechunk the carrier"
+            )
+        if cbytes > MAX_COMPRESSED_CHUNK:
+            raise ValueError(
+                f"Document chunk exceeds {MAX_COMPRESSED_CHUNK >> 20} MiB compressed limit; rechunk the carrier"
+            )
+        expected = min(self.chunksize, self.nbytes - index * self.chunksize)
+        if nbytes != expected:
+            raise ValueError("Document chunk does not match fixed-chunk metadata")
+        chunk = self._schunk.get_chunk(index)
+        if len(chunk) != cbytes:
+            raise ValueError("Document chunk has an invalid compressed length")
+        data = blosc2.decompress(chunk)
+        if len(data) != nbytes:
+            raise ValueError("Decoded document chunk does not match metadata")
+        return data
+
+    def _stream(self, *, streaming=False):
+        self._check_open()
+        return _ChunkReader(self)
+
+    def close(self):
+        self._closed = True
+        self._schunk = None
+
+
+async def _http_range(fs, path, offset, size, frame_size):
+    """Validate HTTP range headers before reading any response body."""
+    kwargs = dict(fs.kwargs)
+    headers = dict(kwargs.pop("headers", {}))
+    headers.update(Range=f"bytes={offset}-{offset + size - 1}", **{"Accept-Encoding": "identity"})
+    session = await fs.set_session()
+    async with session.get(fs.encode_url(path), headers=headers, **kwargs) as response:
+        response.raise_for_status()
+        if (
+            response.status != 206
+            or response.headers.get("Content-Range") != f"bytes {offset}-{offset + size - 1}/{frame_size}"
+            or response.headers.get("Content-Encoding", "identity") != "identity"
+        ):
+            raise ValueError("Remote document requires valid HTTP byte-range support")
+        if int(response.headers.get("Content-Length", size)) != size:
+            raise ValueError("HTTP document range has an invalid length")
+        data = bytearray()
+        async for part in response.content.iter_chunked(64 << 10):
+            if len(data) + len(part) > size:
+                raise ValueError("HTTP document range exceeds requested bytes")
+            data.extend(part)
+        if len(data) != size:
+            raise ValueError("HTTP document range returned a short read")
+        return bytes(data)
+
+
+class _ChunkReader:
+    """Keep at most one decoded chunk between bounded sequential reads."""
+
+    def __init__(self, file):
+        self.file = file
+        self.position = 0
+        self.index = None
+        self.data = None
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, *args):
+        self.data = None
+
+    def seek(self, offset):
+        if not 0 <= offset <= self.file.nbytes:
+            raise ValueError("Invalid document byte offset")
+        self.position = offset
+
+    def read(self, size):
+        self.file._check_open()
+        if not 0 <= size <= MAX_READ_BYTES:
+            raise ValueError("Document stream reads must be bounded to 16 MiB")
+        stop = min(self.position + size, self.file.nbytes)
+        output = bytearray()
+        while self.position < stop:
+            index = self.position // self.file.chunksize
+            if index != self.index:
+                self.data = None
+                self.data = self.file._chunk(index)
+                self.index = index
+            offset = self.position - index * self.file.chunksize
+            length = min(stop - self.position, len(self.data) - offset)
+            output.extend(self.data[offset : offset + length])
+            self.position += length
+        return bytes(output)
diff --git a/src/blosc2/b2view/directory.py b/src/blosc2/b2view/directory.py
new file mode 100644
index 000000000..438ec6b32
--- /dev/null
+++ b/src/blosc2/b2view/directory.py
@@ -0,0 +1,141 @@
+"""Lazy, read-only directory roots with dataset containers as mounted subtrees."""
+
+import os
+from pathlib import Path, PurePosixPath
+
+from blosc2.b2view.ordinary_file import NATIVE_SUFFIXES, local_path, ordinary_filesystem
+from blosc2.core import find_url_separator, is_fsspec_url
+
+CONTAINER_SUFFIXES = {".b2d", ".b2z", ".h5", ".hdf5", ".zarr"}
+
+
+class DirectoryStore:
+    """List only immediate children; open dataset mounts only on selection/expansion."""
+
+    def __init__(self, source, *, storage_options=None, **options):
+        self.source = source
+        self.storage_options = storage_options
+        self.options = options
+        self.fs = None
+        if is_fsspec_url(source):
+            self.fs, self.root = ordinary_filesystem(source, storage_options)
+        else:
+            self.root = local_path(source).resolve()
+        self._browsers = {}
+        self._counts = {}
+
+    def _resolve(self, path):
+        """Return (physical path, mount browser or None, internal mount path)."""
+        from blosc2.b2view.model import StoreBrowser
+
+        parts = PurePosixPath(path).parts
+        parts = [part for part in parts if part != "/"]
+        if ".." in parts:
+            raise ValueError("Directory navigation cannot escape the root")
+        physical = self.root
+        for index, part in enumerate(parts):
+            physical = physical / part if self.fs is None else physical.rstrip("/") + "/" + part
+            if self.fs is None and not physical.is_relative_to(self.root):
+                # Anchors (//, Windows drives/UNC paths) can reset a path join.
+                # Reject them before any stat, symlink check or mounted opener.
+                raise ValueError("Directory navigation cannot escape the root")
+            if self.fs is None and physical.is_symlink():
+                raise ValueError("Directory symlinks are not followed")
+            suffix = PurePosixPath(part).suffix.lower()
+            is_dir = physical.is_dir() if self.fs is None else self.fs.isdir(physical)
+            if suffix in NATIVE_SUFFIXES | CONTAINER_SUFFIXES or not is_dir:
+                key = "/" + "/".join(parts[: index + 1])
+                if key not in self._browsers:
+                    source = os.fspath(physical) if self.fs is None else self.fs.unstrip_protocol(physical)
+                    separator = find_url_separator(self.source)
+                    if self.fs is not None and separator != -1:
+                        source += self.source[separator:]
+                    options = dict(self.options)
+                    if options.get("cache_dir") is not None:
+                        import hashlib
+
+                        # Mounted datasets need independent snapshot/lock roots.
+                        cache_key = hashlib.sha256(source.encode()).hexdigest()
+                        options["cache_dir"] = str(Path(options["cache_dir"]) / cache_key)
+                    self._browsers[key] = StoreBrowser(
+                        source, storage_options=self.storage_options, **options
+                    )
+                return physical, self._browsers[key], "/" + "/".join(parts[index + 1 :])
+        return physical, None, "/"
+
+    def list_children(self, path):
+        from blosc2.b2view.compressed_file import compressed_document
+        from blosc2.b2view.model import NodeInfo
+
+        physical, browser, inner = self._resolve(path)
+        prefix = path.rstrip("/")
+        if browser is not None:
+            return [
+                NodeInfo(prefix + "/" + node.name, node.name, node.kind, node.has_children)
+                for node in browser.list_children(inner)
+            ]
+        if self.fs is None:
+            entries = [(entry.name, entry.is_dir(), entry.is_symlink()) for entry in physical.iterdir()]
+        else:
+            entries = [
+                (PurePosixPath(entry["name"].rstrip("/")).name, entry["type"] == "directory", False)
+                for entry in self.fs.ls(physical, detail=True)
+            ]
+        nodes = []
+        for name, is_dir, symlink in sorted(entries):
+            suffix = PurePosixPath(name).suffix.lower()
+            mount = suffix in CONTAINER_SUFFIXES
+            directory = is_dir and suffix not in NATIVE_SUFFIXES
+            kind = (
+                "unsupported"
+                if symlink
+                else "group"
+                if directory or mount
+                else {".b2nd": "ndarray", ".parquet": "ctable", ".b2": "schunk", ".b2frame": "schunk"}.get(
+                    suffix, "unknown" if suffix in NATIVE_SUFFIXES else "file"
+                )
+            )
+            nodes.append(NodeInfo(prefix + "/" + name, name, kind, not symlink and (directory or mount)))
+            if not is_dir and not symlink and compressed_document(name):
+                nodes[-1] = NodeInfo(prefix + "/" + name, name, "file", False)
+        self._counts[path] = len(nodes)
+        return nodes
+
+    def get_info(self, path):
+        from blosc2.b2view.model import ObjectInfo
+
+        physical, browser, inner = self._resolve(path)
+        if browser is not None:
+            info = browser.get_info(inner)
+            return ObjectInfo(path, info.kind, info.metadata, info.user_attrs, path)
+        metadata = {"type": "Local directory" if self.fs is None else "FSSPEC directory"}
+        if path in self._counts:
+            metadata["children"] = self._counts[path]
+        return ObjectInfo(path, "group", metadata, display_path=path)
+
+    def __getitem__(self, path):
+        _, browser, inner = self._resolve(path)
+        if browser is None:
+            raise TypeError("Directory groups have no array/file payload")
+        return browser._get_object(inner)
+
+    def close(self):
+        error = None
+        try:
+            for browser in self._browsers.values():
+                try:
+                    browser.close()
+                except Exception as exc:
+                    error = exc
+        finally:
+            self._browsers.clear()
+        if error is not None:
+            raise error
+
+
+def is_directory(source, storage_options=None):
+    """Check only the root, not its descendants."""
+    if is_fsspec_url(source):
+        fs, path = ordinary_filesystem(source, storage_options)
+        return fs.isdir(path)
+    return local_path(source).is_dir()
diff --git a/src/blosc2/b2view/file_preview.py b/src/blosc2/b2view/file_preview.py
new file mode 100644
index 000000000..c397b1639
--- /dev/null
+++ b/src/blosc2/b2view/file_preview.py
@@ -0,0 +1,160 @@
+"""Bounded, passive previews of untrusted ordinary-file content."""
+
+import codecs
+import io
+import re
+import warnings
+from pathlib import PurePosixPath
+
+TEXT_BYTES = 64 << 10
+TEXT_LINES = 1000
+IMAGE_BYTES = 16 << 20
+IMAGE_PIXELS = (64 << 20) // 4
+TEXT_SUFFIXES = {".md", ".txt", ".rst", ".csv", ".json", ".yaml", ".yml", ".log", ".py", ".ipynb"}
+IMAGE_SUFFIXES = {".jpg", ".jpeg", ".png"}
+EXTERNAL_SUFFIXES = IMAGE_SUFFIXES | {".pdf", ".md", ".txt"}
+
+
+def file_actions(name, *, markdown=False):
+    """Use the same action hints for successful previews and fallback panels."""
+    suffix = PurePosixPath(name).suffix.lower()
+    actions = ["D: download"]
+    if suffix in EXTERNAL_SUFFIXES:
+        actions.append("O: open externally")
+    if markdown and suffix == ".md":
+        actions.append("T: raw/Markdown")
+    elif markdown and suffix == ".ipynb":
+        actions.append("T: raw/notebook")
+    return " · ".join(actions)
+
+
+def file_fallback(name, status, reason):
+    """Describe a passive preview failure without suggesting unsupported actions."""
+    return {
+        "preview_status": status,
+        "message": safe_text(reason),
+        "actions": file_actions(name, markdown=PurePosixPath(name).suffix.lower() == ".ipynb"),
+    }
+
+
+def safe_text(text):
+    """Remove ANSI/OSC sequences and unsafe terminal controls from decoded text."""
+    text = re.sub(r"\x1b\][^\x07\x1b]*(?:\x07|\x1b\\)", "", text)
+    text = re.sub(r"\x1b\[[0-?]*[ -/]*[@-~]", "", text)
+    return "".join(c for c in text if c in "\n\t" or (ord(c) >= 32 and not 127 <= ord(c) < 160))
+
+
+def preview_file(file, *, raw=False):
+    """Return metadata/render content without executing links or decoding objects."""
+    suffix = PurePosixPath(file.name).suffix.lower()
+    try:
+        if suffix == ".pdf":
+            return file_fallback(file.name, "Preview unavailable", "PDF has no inline preview.")
+        if suffix in IMAGE_SUFFIXES:
+            return preview_image(file)
+        if suffix == ".ipynb" and not raw:
+            from blosc2.b2view.notebook_preview import preview_notebook
+
+            return preview_notebook(file)
+        if suffix not in TEXT_SUFFIXES:
+            return file_fallback(file.name, "Preview unavailable", "Binary/unknown file.")
+        data = file.read_bytes(0, min(file.nbytes, TEXT_BYTES))
+        if b"\0" in data:
+            return file_fallback(file.name, "Preview unavailable", "Binary content despite text suffix.")
+        truncated = file.nbytes > len(data)
+        decoder = codecs.getincrementaldecoder("utf-8-sig")("replace")
+        text = safe_text(decoder.decode(data, final=not truncated))
+        lines = text.splitlines(keepends=True)
+        truncated |= len(lines) > TEXT_LINES
+        text = "".join(lines[:TEXT_LINES])
+        notice = "Preview truncated (64 KiB / 1,000 line limit)." if truncated else ""
+        if "\ufffd" in text:
+            notice += " Invalid UTF-8 replaced."
+        return {
+            "file_text": text,
+            "markdown": suffix == ".md" and not raw,
+            "notice": notice,
+            "message": file_actions(file.name, markdown=True),
+        }
+    except Exception as error:
+        # The app supplies a credential-redacted diagnostic. Do not expose raw
+        # transport exception strings to standalone render callers either.
+        result = file_fallback(
+            file.name, "Preview failed", f"{type(error).__name__}: Could not read preview."
+        )
+        result["preview_error"] = error
+        return result
+
+
+def preview_image(file):
+    try:
+        from PIL import Image  # noqa: F401
+    except ImportError:
+        return file_fallback(
+            file.name, "Missing dependency", "Image preview needs Pillow. Install blosc2[images]."
+        )
+    if file.nbytes > IMAGE_BYTES:
+        return file_fallback(file.name, "Preview unavailable", "Automatic image preview exceeds 16 MiB.")
+    return preview_image_bytes(file.read_bytes(0, file.nbytes), file.name)
+
+
+def preview_image_bytes(data, name, *, max_pixels=None):
+    """Decode passive PNG/JPEG bytes with the shared image safety limits."""
+    max_pixels = IMAGE_PIXELS if max_pixels is None else min(max_pixels, IMAGE_PIXELS)
+    try:
+        from PIL import Image, ImageOps
+    except ImportError:
+        return file_fallback(
+            name, "Missing dependency", "Image preview needs Pillow. Install blosc2[images]."
+        )
+    if len(data) > IMAGE_BYTES:
+        return file_fallback(name, "Preview unavailable", "Automatic image preview exceeds 16 MiB.")
+    if not (data.startswith(b"\xff\xd8\xff") or data.startswith(b"\x89PNG\r\n\x1a\n")):
+        return file_fallback(name, "Preview failed", "Invalid JPEG/PNG signature.")
+    with warnings.catch_warnings():
+        warnings.simplefilter("error", Image.DecompressionBombWarning)
+        with Image.open(io.BytesIO(data)) as original:
+            if original.format not in {"JPEG", "PNG"} or original.width * original.height > max_pixels:
+                return file_fallback(
+                    name, "Preview unavailable", "Image exceeds decoded pixel budget (64 MiB RGBA)."
+                )
+            size, format_name = original.size, original.format
+            original.seek(0)
+            image = ImageOps.exif_transpose(original)
+            image.thumbnail((1600, 1200))
+            image = image.convert("RGB")
+    return {
+        "file_image": image,
+        "image_pixels": size[0] * size[1],
+        "message": f"{format_name} · {size[0]} × {size[1]} · {file_actions(name)}",
+    }
+
+
+def open_external(path):
+    """Launch a user-confirmed document with no shell or credential-bearing URL."""
+    import os
+    import shutil
+    import subprocess
+    import sys
+    from pathlib import Path
+
+    path = Path(path).absolute()
+    if path.suffix.lower() not in EXTERNAL_SUFFIXES:
+        raise ValueError("External opening is restricted to PDF, JPEG/PNG, Markdown and text")
+    with path.open("rb") as file:
+        signature = file.read(1024)
+    suffix = path.suffix.lower()
+    if (
+        (suffix == ".pdf" and not signature.startswith(b"%PDF-"))
+        or (suffix in {".jpg", ".jpeg"} and not signature.startswith(b"\xff\xd8\xff"))
+        or (suffix == ".png" and not signature.startswith(b"\x89PNG\r\n\x1a\n"))
+        or (suffix in {".txt", ".md"} and b"\0" in signature)
+    ):
+        raise ValueError("File content does not match the external-open document type")
+    if sys.platform == "win32":
+        os.startfile(str(path))
+        return
+    launcher = "open" if sys.platform == "darwin" else "xdg-open"
+    if shutil.which(launcher) is None:
+        raise RuntimeError(f"{launcher} is unavailable; open the downloaded file manually: {path}")
+    subprocess.run([launcher, str(path)], check=True, timeout=10, capture_output=True)
diff --git a/src/blosc2/b2view/model.py b/src/blosc2/b2view/model.py
index cd55ca5bd..62bc97283 100644
--- a/src/blosc2/b2view/model.py
+++ b/src/blosc2/b2view/model.py
@@ -10,6 +10,8 @@
 import numpy as np
 
 import blosc2
+from blosc2.b2view.directory import DirectoryStore, is_directory
+from blosc2.b2view.ordinary_file import OrdinaryFile, ordinary_source
 from blosc2.core import is_fsspec_url, parse_container_url
 
 # Above this uncompressed size, plot_series does not read the whole series at
@@ -131,6 +133,7 @@ class ObjectInfo:
     kind: str
     metadata: dict[str, Any]
     user_attrs: dict[str, Any] | None = None
+    display_path: str | None = None
 
 
 @dataclass
@@ -243,6 +246,33 @@ def total_for_dim(self, dim: int) -> int:
         return 0
 
 
+def _open_viewer_source(urlpath, storage_options, **options):
+    from blosc2.b2view.compressed_file import CompressedFile, compressed_document
+    from blosc2.b2view.file_preview import IMAGE_SUFFIXES, TEXT_SUFFIXES
+
+    if compressed_document(urlpath):
+        return CompressedFile(urlpath, storage_options)
+    if is_directory(urlpath, storage_options):
+        return DirectoryStore(urlpath, storage_options=storage_options, **options)
+    file = OrdinaryFile(urlpath, storage_options)
+    # Preserve native frames with nonstandard names. Known ordinary document
+    # types need no payload fetch merely to identify them.
+    suffix = PurePosixPath(file.name).suffix.lower()
+    try:
+        native = (
+            suffix not in TEXT_SUFFIXES | IMAGE_SUFFIXES | {".pdf", ".ipynb"}
+            and file.nbytes >= 10
+            and file.read_bytes(0, 10) == b"\x9e\xa8b2frame\x00"
+        )
+    except BaseException:
+        file.close()
+        raise
+    if not native:
+        return file
+    file.close()
+    return None
+
+
 class StoreBrowser:
     """Small, read-only adapter used by the b2view UI.
 
@@ -260,6 +290,7 @@ def __init__(
         storage_options: dict[str, Any] | None = None,
         cache_dir: str | None = None,
         max_cache_bytes: int | None = None,
+        remote_service: str = "auto",
     ):
         self.urlpath = urlpath
         self.cache_dir = cache_dir
@@ -269,9 +300,13 @@ def __init__(
         self._remote_child_counts = {}
         self._remote_leaf_path = None
         self.store = self._open_store(
-            urlpath, storage_options, cache_dir=cache_dir, max_cache_bytes=max_cache_bytes
+            urlpath,
+            storage_options,
+            cache_dir=cache_dir,
+            max_cache_bytes=max_cache_bytes,
+            remote_service=remote_service,
         )
-        self.is_tree = isinstance(self.store, blosc2.TreeStore) or (
+        self.is_tree = isinstance(self.store, (blosc2.TreeStore, DirectoryStore)) or (
             isinstance(self.store, blosc2.RemoteStore) and self.store.kind() == "group"
         )
         # Per-path row filters for CTable nodes (path -> expr / where() view)
@@ -304,8 +339,29 @@ def _open_store(
         *,
         cache_dir: str | None = None,
         max_cache_bytes: int | None = None,
+        remote_service: str = "auto",
     ):
         options = {} if storage_options is None else {"storage_options": storage_options}
+        from blosc2.caterva2_url import caterva2_urlpath
+
+        if ordinary_source(urlpath, remote_service):
+            file = _open_viewer_source(
+                urlpath,
+                storage_options,
+                cache_dir=cache_dir,
+                max_cache_bytes=max_cache_bytes,
+                remote_service=remote_service,
+            )
+            if file is not None:
+                return file
+        if remote_service == "caterva2" or (
+            remote_service == "auto" and caterva2_urlpath(urlpath) is not None
+        ):
+            if cache_dir is not None:
+                options["cache_dir"] = cache_dir
+            if max_cache_bytes is not None:
+                options["max_cache_bytes"] = max_cache_bytes
+            return blosc2.open(urlpath, mode="r", lazy=True, remote_service=remote_service, **options)
         if is_fsspec_url(urlpath):
             _, _, source_format = parse_container_url(urlpath)
             if source_format in {"b2z", "zarr", "hdf5"}:
@@ -332,7 +388,7 @@ def _open_store(
             options["max_cache_bytes"] = 64 << 20 if max_cache_bytes is None else max_cache_bytes
             if cache_dir is not None:
                 options["cache_dir"] = cache_dir
-        return blosc2.open(urlpath, mode="r", **options)
+        return blosc2.open(urlpath, mode="r", remote_service=remote_service, **options)
 
     def _release_remote_leaf(self):
         if self._remote_leaf is not None:
@@ -365,19 +421,27 @@ def normalize_path(path: str) -> str:
     def list_children(self, path: str = "/") -> list[NodeInfo]:
         """Return direct children for *path*."""
         path = self.normalize_path(path)
+        if isinstance(self.store, DirectoryStore):
+            return self.store.list_children(path)
         if isinstance(self.store, blosc2.RemoteStore):
             if self.store.kind(path) not in {"group", "remote_store"}:
                 return []
             with self.store[path] as group:
                 children = []
                 for name in group:
-                    kind = group.kind(name)
+                    try:
+                        kind = group.kind(name)
+                    except Exception:
+                        # Metadata failure in one mounted source must not hide
+                        # its healthy siblings. Selecting it displays the error
+                        # and can retry discovery without a cached failure.
+                        kind = "unavailable"
                     children.append(
                         NodeInfo(
                             path=self.normalize_path(path.rstrip("/") + "/" + name),
                             name=name,
                             kind=kind,
-                            has_children=kind in {"group", "remote_store"},
+                            has_children=kind in {"group", "remote_store", "unavailable"},
                         )
                     )
                 self._remote_child_counts[path] = len(children)
@@ -404,6 +468,8 @@ def list_children(self, path: str = "/") -> list[NodeInfo]:
     def kind(self, path: str) -> str:
         """Classify a browser path."""
         path = self.normalize_path(path)
+        if isinstance(self.store, DirectoryStore):
+            return self.store.get_info(path).kind
         if isinstance(self.store, blosc2.RemoteStore):
             return self.store.kind(path)
         if not self.is_tree:
@@ -417,6 +483,8 @@ def kind(self, path: str) -> str:
     def get_info(self, path: str) -> ObjectInfo:
         """Return metadata for *path*."""
         path = self.normalize_path(path)
+        if isinstance(self.store, DirectoryStore):
+            return self.store.get_info(path)
         if isinstance(self.store, blosc2.RemoteStore):
             return self._remote_info(path)
         kind = self.kind(path)
@@ -442,23 +510,51 @@ def get_info(self, path: str) -> ObjectInfo:
         if user_attrs is None and self.is_tree:
             store_attrs = getattr(self.store, "attrs", getattr(self.store, "vlmeta", None))
             user_attrs = self._attrs_dict(store_attrs)
-        return ObjectInfo(path=path, kind=kind, metadata=metadata, user_attrs=user_attrs)
+        return ObjectInfo(
+            path=path,
+            kind=kind,
+            metadata=metadata,
+            user_attrs=user_attrs,
+            display_path=self._display_path(path),
+        )
+
+    def _display_path(self, path):
+        """Keep service paths fully qualified without changing browser navigation."""
+        if isinstance(
+            self.store, (blosc2.RemoteStore, blosc2.RemoteArray, blosc2.RemoteCTable, blosc2.RemoteFile)
+        ):
+            source = self.store.source
+            if source["kind"] == "caterva2":
+                full = "/".join(part for part in (source["path"], path.strip("/")) if part)
+                return full if full.startswith("@") else "/" + full
+            if source["kind"] == "caterva2_repository" and path.startswith("/@"):
+                return path.lstrip("/")
+        elif isinstance(self.store, blosc2.C2Array):
+            full = self.store.path.strip("/")
+            return full if full.startswith("@") else "/" + full
+        return path
 
     def _remote_info(self, path):
         node = self.store.get_info(path)
         metadata = {"type": f"{self.store.source['kind'].upper()} {node.kind}"}
+        if node.catalog_attrs:
+            metadata["catalog_attrs"] = dict(node.catalog_attrs)
         attrs = node.attrs
-        if node.kind == "ndarray":
+        if node.kind in {"ndarray", "ctable", "file"}:
             obj = self._get_object(path)
             metadata.update(object_metadata(obj))
-            attrs = self._attrs_dict(obj.vlmeta)
+            if node.kind == "ctable":
+                metadata["type"] = f"{self.store.source['kind'].upper()} {node.kind}"
+            attrs = self._attrs_dict(obj.attrs)
         else:
             self._release_remote_leaf()
             if node.kind in {"group", "remote_store"} and path in self._remote_child_counts:
                 metadata["children"] = self._remote_child_counts[path]
             if node.diagnostic:
                 metadata["preview" if node.kind == "unsupported" else "notice"] = node.diagnostic
-        return ObjectInfo(path, node.kind, metadata, attrs)
+            if isinstance(self.store, blosc2.RemoteRepository) and path == "/" and not self.store.keys():
+                metadata["notice"] = "No accessible roots"
+        return ObjectInfo(path, node.kind, metadata, attrs, display_path=self._display_path(path))
 
     def preview(
         self,
@@ -473,6 +569,7 @@ def preview(
         col_start: int = 0,
         slice_indices: list[int] | None = None,
         layout: DataSliceLayout | None = None,
+        raw_text: bool = False,
     ) -> Any:
         """Return a bounded data preview for *path*.
 
@@ -482,6 +579,10 @@ def preview(
         path = self.normalize_path(path)
         obj = self._get_object(path)
         kind = object_kind(obj)
+        if kind == "file":
+            from blosc2.b2view.file_preview import preview_file
+
+            return preview_file(obj, raw=raw_text)
         if kind in {"ndarray", "c2array"}:
             shape = tuple(getattr(obj, "shape", ()) or ())
             if slices is None:
@@ -521,7 +622,10 @@ def preview(
         if kind == "schunk":
             stop = start + max_rows if stop is None else stop
             return preview_schunk(obj, start=start, stop=stop)
-        return {"message": f"Preview is not supported for {kind!r} objects."}
+        return {
+            "preview_status": "Preview unavailable",
+            "message": f"Preview is not supported for {kind!r} objects.",
+        }
 
     def plot_series(
         self,
@@ -567,6 +671,8 @@ def plot_series(
             # fast-path spans the whole column in original order, so it is only
             # valid when nothing narrows *or reorders* the series.
             view = self._ordered_object(path, obj)
+            if isinstance(view, blosc2.RemoteCTable):
+                raise NotImplementedError("Plotting remote tables requires a bounded locked row window")
             narrowed = view is not obj
             n = len(view)
             start, stop = self._clamp_range(row_start, row_stop, n)
@@ -668,6 +774,8 @@ def read_series(
             # Window > filter > sort, matching preview()/read_cell() so the
             # hi-res view tracks the visible grid (rows and order).
             view = self._ordered_object(path, obj)
+            if isinstance(view, blosc2.RemoteCTable):
+                raise NotImplementedError("Plotting remote tables requires a bounded locked row window")
             n = len(view)
             start, stop = self._clamp_range(row_start, row_stop, n)
             stride = self._series_stride(stop - start, max_points)
@@ -745,6 +853,8 @@ def read_xy(
         # Window > filter > sort, matching read_series() so the scatter tracks
         # exactly the visible rows (and order).
         view = self._ordered_object(path, obj)
+        if isinstance(view, blosc2.RemoteCTable):
+            raise NotImplementedError("Scatter plotting remote tables requires a bounded locked row window")
         n = len(view)
         start, stop = self._clamp_range(row_start, row_stop, n)
         width = stop - start
@@ -930,6 +1040,10 @@ def column_names(self, path: str) -> list[str] | None:
         names = list(getattr(self._get_object(path), "col_names", []) or [])
         return names or None
 
+    def supports_table_transforms(self, path: str) -> bool:
+        """Whether filtering/sorting/grouping can run without remote materialization."""
+        return not isinstance(self._get_object(self.normalize_path(path)), blosc2.RemoteCTable)
+
     def set_filter(self, path: str, expr: str | None) -> int:
         """Set or clear the row filter of a CTable path; return its row count.
 
@@ -937,6 +1051,10 @@ def set_filter(self, path: str, expr: str | None) -> int:
         propagate to the caller and leave any previous filter untouched.
         """
         path = self.normalize_path(path)
+        if expr and not self.supports_table_transforms(path):
+            raise NotImplementedError(
+                "Filtering remote tables is unsupported; materialize a bounded selection first"
+            )
         expr = (expr or "").strip()
         if not expr:
             self._filters.pop(path, None)
@@ -973,6 +1091,10 @@ def set_sort(self, path: str, column: str, reverse: bool) -> None:
         streams from the index, so the full table is never materialised.
         """
         path = self.normalize_path(path)
+        if not self.supports_table_transforms(path):
+            raise NotImplementedError(
+                "Sorting remote tables is unsupported; materialize a bounded selection first"
+            )
         self._window_views.pop(path, None)
         view = self._row_source(path).sort_by(column, ascending=not reverse, view=True)
         self._sorts[path] = (column, reverse)
@@ -1012,6 +1134,10 @@ def set_row_window(self, path: str, start: int, stop: int) -> int:
         currently visible (so it composes over any active row filter).  Paging
         then cannot leave the range because the view reports only its own rows.
         """
+        return self.install_row_window(path, self.prepare_row_window(path, start, stop))
+
+    def prepare_row_window(self, path: str, start: int, stop: int):
+        """Read a bounded window without publishing it (may perform remote I/O)."""
         path = self.normalize_path(path)
         # The sort view already incorporates any filter, so prefer it; fall back
         # to the bare filter view, then the base table.
@@ -1021,8 +1147,11 @@ def set_row_window(self, path: str, start: int, stop: int) -> int:
             base = self._filter_views[path]
         else:
             base = self._get_object(path)
-        view = base.slice(start, stop, copy=False)
-        self._window_views[path] = view
+        return base.slice(start, stop, copy=isinstance(base, blosc2.RemoteCTable))
+
+    def install_row_window(self, path: str, view) -> int:
+        """Publish an already prepared window without remote I/O."""
+        self._window_views[self.normalize_path(path)] = view
         return len(view)
 
     def clear_row_window(self, path: str) -> None:
@@ -1073,6 +1202,10 @@ def set_group(self, path: str, key: str, op: str, value_col: str | None) -> int:
         """
         path = self.normalize_path(path)
         # Memoize the materialized result: the store is read-only, so a given
+        if not self.supports_table_transforms(path):
+            raise NotImplementedError(
+                "Grouping remote tables is unsupported; materialize a bounded selection first"
+            )
         # (path, filter, key, op, value_col) always aggregates to the same tiny
         # CTable.  The active filter expr is part of the key so a filtered group
         # never collides with the unfiltered one.
@@ -1319,6 +1452,8 @@ def object_kind(obj: Any) -> str:
     """Return a stable b2view kind string for *obj*."""
     if isinstance(obj, blosc2.TreeStore):
         return "group"
+    if isinstance(obj, (blosc2.RemoteFile, OrdinaryFile)):
+        return "file"
     if isinstance(obj, (blosc2.NDArray, blosc2.RemoteArray, blosc2.Proxy)):
         return "ndarray"
     if isinstance(obj, blosc2.CTable):
@@ -1333,7 +1468,37 @@ def object_kind(obj: Any) -> str:
 def object_metadata(obj: Any) -> dict[str, Any]:
     """Extract lightweight metadata from a supported object."""
     kind = object_kind(obj)
+    if kind == "file":
+        from blosc2.b2view.compressed_file import CompressedFile
+        from blosc2.b2view.file_preview import file_actions
+
+        metadata = {
+            "type": "Caterva2 file"
+            if isinstance(obj, blosc2.RemoteFile)
+            else "Local file"
+            if obj.fs is None
+            else "FSSPEC file",
+            "name": obj.name,
+            "media type (hint)": obj.media_type,
+            "nbytes": obj.nbytes,
+            "actions": file_actions(obj.name, markdown=True),
+        }
+        if isinstance(obj, blosc2.RemoteFile):
+            metadata.update(cbytes=obj.cbytes, chunksize=obj.chunksize, nchunks=obj.nchunks)
+        elif isinstance(obj, CompressedFile):
+            metadata.update(
+                type="Compressed remote file" if obj.fs is not None else "Compressed local file",
+                carrier=obj.carrier,
+                cbytes=obj.cbytes,
+                chunksize=obj.chunksize,
+                nchunks=obj.nchunks,
+            )
+        return metadata
     if kind in {"ndarray", "c2array"}:
+        try:
+            cbytes = getattr(obj, "cbytes", None)
+        except NotImplementedError:
+            cbytes = None
         return {
             "shape": getattr(obj, "shape", None),
             "ndim": len(getattr(obj, "shape", ()) or ()),
@@ -1341,7 +1506,7 @@ def object_metadata(obj: Any) -> dict[str, Any]:
             "chunks": getattr(obj, "chunks", None),
             "blocks": getattr(obj, "blocks", None),
             "nbytes": getattr(obj, "nbytes", None),
-            "cbytes": getattr(obj, "cbytes", None),
+            "cbytes": cbytes,
         }
     if kind == "ctable":
         try:
diff --git a/src/blosc2/b2view/notebook_preview.py b/src/blosc2/b2view/notebook_preview.py
new file mode 100644
index 000000000..dd1bf40e8
--- /dev/null
+++ b/src/blosc2/b2view/notebook_preview.py
@@ -0,0 +1,178 @@
+"""Bounded, passive notebook cells, text and saved PNG/JPEGs; no kernel or HTML."""
+
+import base64
+import json
+
+from blosc2.b2view.file_preview import (
+    IMAGE_BYTES,
+    IMAGE_PIXELS,
+    TEXT_BYTES,
+    TEXT_LINES,
+    file_actions,
+    file_fallback,
+    preview_image_bytes,
+    safe_text,
+)
+
+NOTEBOOK_BYTES = 2 << 20
+NOTEBOOK_CELLS = 100
+NOTEBOOK_IMAGES = 8
+LANGUAGES = {"python", "julia", "r", "javascript", "typescript", "bash", "sh", "sql", "c", "cpp", "text"}
+
+
+def _text(value):
+    if isinstance(value, list) and all(isinstance(part, str) for part in value):
+        value = "".join(value)
+    if not isinstance(value, str):
+        raise ValueError("Notebook cell/output text must be a string or list of strings")
+    return safe_text(value)
+
+
+class _TextBudget:
+    def __init__(self):
+        self.bytes = TEXT_BYTES
+        self.lines = TEXT_LINES
+        self.truncated = False
+
+    def take(self, text):
+        lines = text.splitlines(keepends=True)
+        self.truncated |= len(lines) > self.lines
+        text = "".join(lines[: self.lines])
+        encoded = text.encode("utf-8")
+        self.truncated |= len(encoded) > self.bytes
+        text = encoded[: self.bytes].decode("utf-8", errors="ignore")
+        self.bytes -= len(text.encode("utf-8"))
+        self.lines -= len(text.splitlines())
+        return text
+
+
+class _ImageBudget:
+    def __init__(self):
+        self.bytes = IMAGE_BYTES
+        self.pixels = IMAGE_PIXELS
+        self.count = 0
+        self.notices = set()
+
+    def take(self, data):
+        mime = next((mime for mime in ("image/png", "image/jpeg") if mime in data), None)
+        if mime is None:
+            return None
+        if self.count >= NOTEBOOK_IMAGES or self.pixels <= 0 or self.bytes <= 0:
+            self.notices.add("Saved images omitted: notebook image budget reached.")
+            return None
+        try:
+            value = data[mime]
+            if isinstance(value, list) and all(isinstance(part, str) for part in value):
+                value = "".join(value)
+            if not isinstance(value, str):
+                raise ValueError("Invalid image data")
+            encoded = "".join(value.split())
+            if len(encoded) > 4 * ((self.bytes + 2) // 3):
+                self.notices.add("Saved image omitted: encoded byte budget exceeded.")
+                return None
+            payload = base64.b64decode(encoded, validate=True)
+            if len(payload) > self.bytes:
+                self.notices.add("Saved image omitted: encoded byte budget exceeded.")
+                return None
+            signature = b"\x89PNG\r\n\x1a\n" if mime == "image/png" else b"\xff\xd8\xff"
+            if not payload.startswith(signature):
+                raise ValueError("Image signature does not match MIME type")
+            result = preview_image_bytes(
+                payload, "output.png" if mime == "image/png" else "output.jpg", max_pixels=self.pixels
+            )
+            if "file_image" not in result:
+                self.notices.add(f"Saved image omitted: {result['message']}")
+                return None
+            self.bytes -= len(payload)
+            self.pixels -= result["image_pixels"]
+            self.count += 1
+            return result["file_image"]
+        except Exception:
+            self.notices.add("Saved image omitted: invalid or unsafe PNG/JPEG data.")
+            return None
+
+
+def _outputs(cell, budget, image_budget):
+    outputs = cell.get("outputs", [])
+    if not isinstance(outputs, list):
+        raise ValueError("Notebook outputs must be a list")
+    text, images, skipped = [], [], 0
+    for output in outputs:
+        if not isinstance(output, dict):
+            raise ValueError("Notebook output must be an object")
+        kind = output.get("output_type")
+        if kind == "stream":
+            text.append(_text(output.get("text", "")))
+        elif kind == "error":
+            traceback = output.get("traceback", [])
+            if not isinstance(traceback, list):
+                raise ValueError("Notebook traceback must be a list")
+            text.append("\n".join(_text(line) for line in traceback))
+        elif kind in {"display_data", "execute_result"}:
+            data = output.get("data", {})
+            if not isinstance(data, dict):
+                raise ValueError("Notebook output data must be an object")
+            if "text/plain" in data:
+                text.append(_text(data["text/plain"]))
+            image = image_budget.take(data)
+            if image is not None:
+                images.append(image)
+            skipped += int(any(mime not in {"text/plain", "image/png", "image/jpeg"} for mime in data))
+        else:
+            skipped += 1
+    return budget.take("\n".join(part for part in text if part)), images, skipped
+
+
+def preview_notebook(file):
+    """Parse capped nbformat-4 JSON; only text and static PNG/JPEG outputs are decoded."""
+    if file.nbytes > NOTEBOOK_BYTES:
+        return file_fallback(
+            file.name,
+            "Preview unavailable",
+            "Notebook exceeds 2 MiB input limit; download to view it separately.",
+        )
+    notebook = json.loads(file.read_bytes(0, file.nbytes))
+    if not isinstance(notebook, dict) or notebook.get("nbformat") != 4:
+        return file_fallback(file.name, "Preview unavailable", "Only nbformat 4 notebooks are supported.")
+    cells = notebook.get("cells")
+    if not isinstance(cells, list):
+        raise ValueError("Notebook cells must be a list")
+    metadata = notebook.get("metadata", {})
+    language = "text"
+    if isinstance(metadata, dict) and isinstance(metadata.get("language_info"), dict):
+        name = metadata["language_info"].get("name")
+        if isinstance(name, str) and name.lower() in LANGUAGES:
+            language = name.lower()
+    budget = _TextBudget()
+    image_budget = _ImageBudget()
+    rendered, skipped = [], 0
+    for index, cell in enumerate(cells[:NOTEBOOK_CELLS]):
+        if not isinstance(cell, dict):
+            raise ValueError("Notebook cell must be an object")
+        kind = cell.get("cell_type")
+        if kind not in {"code", "markdown", "raw"}:
+            skipped += 1
+            continue
+        source = budget.take(_text(cell.get("source", "")))
+        output, images, omitted = _outputs(cell, budget, image_budget) if kind == "code" else ("", [], 0)
+        skipped += omitted
+        rendered.append(
+            {"index": index + 1, "kind": kind, "source": source, "output": output, "images": images}
+        )
+        if not budget.bytes or not budget.lines:
+            budget.truncated |= index + 1 < len(cells)
+            break
+    notice = []
+    if budget.truncated or len(cells) > NOTEBOOK_CELLS:
+        notice.append("Preview truncated (100 cells / 64 KiB text / 1,000 lines).")
+    if skipped:
+        notice.append(
+            f"{skipped} unsupported cells/rich outputs omitted (HTML, scripts, SVG and widgets are not rendered)."
+        )
+    notice.extend(sorted(image_budget.notices))
+    return {
+        "notebook_cells": rendered,
+        "language": language,
+        "notice": " ".join(notice),
+        "message": f"Notebook · {len(rendered)}/{len(cells)} cells · passive preview · {file_actions(file.name, markdown=True)}",
+    }
diff --git a/src/blosc2/b2view/ordinary_file.py b/src/blosc2/b2view/ordinary_file.py
new file mode 100644
index 000000000..135b7b8f4
--- /dev/null
+++ b/src/blosc2/b2view/ordinary_file.py
@@ -0,0 +1,212 @@
+"""Viewer-only read-only adapters for local and fsspec ordinary files."""
+
+import mimetypes
+import os
+import stat
+import tempfile
+from pathlib import Path, PurePosixPath
+from urllib.parse import urlsplit
+from urllib.request import url2pathname
+
+import blosc2
+from blosc2.core import find_url_separator, fsspec_filesystem, is_fsspec_url, parse_container_url
+
+MAX_READ_BYTES = 16 << 20
+TRANSFER_BYTES = 1 << 20
+NATIVE_SUFFIXES = {".b2", ".b2nd", ".b2frame", ".b2b", ".b2d", ".b2z", ".b2t", ".b2e"}
+
+
+def _source_member(source):
+    separator = find_url_separator(source)
+    return source if separator == -1 else source[:separator]
+
+
+def ordinary_source(urlpath, remote_service="auto"):
+    """Identify direct file inputs without stealing container/service URLs."""
+    from blosc2.caterva2_url import caterva2_urlpath
+
+    urlpath = os.fspath(urlpath)
+    if remote_service == "caterva2" or (remote_service == "auto" and caterva2_urlpath(urlpath) is not None):
+        return False
+    from blosc2.b2view.compressed_file import compressed_document
+
+    if compressed_document(urlpath):
+        return True
+    base, dataset, source_format = parse_container_url(urlpath)
+    if dataset is not None or source_format is not None:
+        return False
+    member = _source_member(str(base))
+    parsed = urlsplit(member)
+    # HTTP authorities are hosts, not filenames (e.g. service.example.com).
+    # Archive/member protocols may instead carry the filename in the authority.
+    name = parsed.path if parsed.scheme in {"http", "https"} else parsed.path or parsed.netloc
+    suffix = PurePosixPath(name).suffix.lower()
+    if suffix in NATIVE_SUFFIXES:
+        return False
+    if is_fsspec_url(urlpath):
+        # Bare HTTP service bases must retain automatic Caterva2 discovery.
+        return remote_service == "fsspec" or parsed.scheme not in {"http", "https"} or bool(suffix)
+    if urlpath.startswith("file://"):
+        # Validate the authority in the background opener, not the UI constructor.
+        return True
+    return True
+
+
+def local_path(source):
+    """Resolve file:// paths without interpreting URL escapes in ordinary paths."""
+    if source.startswith("file://"):
+        parsed = urlsplit(source)
+        if parsed.netloc not in {"", "localhost"}:
+            raise ValueError("file:// URLs must refer to the local host")
+        # url2pathname handles /C:/ drive prefixes on Windows as well as escapes.
+        return Path(url2pathname(parsed.path))
+    return Path(source)
+
+
+def ordinary_filesystem(source, storage_options=None):
+    """Resolve direct files/directories with bounded default HTTP timeouts."""
+    options = dict(storage_options or {})
+    if urlsplit(source).scheme in {"http", "https"} and find_url_separator(source) == -1:
+        import aiohttp
+
+        client_options = dict(options.get("client_kwargs", {}))
+        client_options.setdefault("timeout", aiohttp.ClientTimeout(total=10))
+        options["client_kwargs"] = client_options
+    return fsspec_filesystem(source, options)
+
+
+def _publish_download(temporary, destination, overwrite):
+    if overwrite:
+        os.replace(temporary, destination)
+    elif blosc2.IS_WASM:
+        # Emscripten has no hard links. Its single-threaded virtual FS cannot
+        # interleave a writer between this check and rename (no callbacks/awaits).
+        if os.path.lexists(destination):
+            raise FileExistsError(destination)
+        os.rename(temporary, destination)
+    else:
+        os.link(temporary, destination)
+
+
+class OrdinaryFile:
+    """A direct regular file with bounded reads and independent transfer aliases.
+
+    Streams are opened only for individual reads/transfers. This adapter does
+    not deserialize containers or participate in the Caterva2 payload cache.
+    """
+
+    def __init__(self, source, storage_options=None):
+        self._closed = False
+        self.source_path = os.fspath(source)
+        self.fs = None
+        if is_fsspec_url(self.source_path):
+            self.fs, self.path = ordinary_filesystem(self.source_path, storage_options)
+            info = self.fs.info(self.path)
+            if info.get("type") != "file":
+                raise ValueError("Select a regular file, not a directory")
+            size = info.get("size")
+            member = urlsplit(_source_member(self.source_path))
+            self.name = PurePosixPath(member.path or self.path).name
+        else:
+            self.path = local_path(self.source_path).absolute()
+            info = self.path.stat()
+            if not stat.S_ISREG(info.st_mode):
+                raise ValueError("Select a regular file, not a directory or device")
+            size = info.st_size
+            self.name = self.path.name
+        if type(size) is not int or size < 0:
+            raise ValueError("Ordinary-file access requires a known nonnegative size")
+        self.nbytes = size
+        self.media_type = mimetypes.guess_type(self.name)[0]
+
+    def _check_open(self):
+        if self._closed:
+            raise RuntimeError("OrdinaryFile is closed")
+
+    def alias(self):
+        """Return an independent handle without extra metadata/payload requests."""
+        import copy
+
+        self._check_open()
+        return copy.copy(self)
+
+    def _stream(self, *, streaming=False):
+        self._check_open()
+        if self.fs is None:
+            return self.path.open("rb")
+        # Disable speculative block caching; each read is explicitly bounded.
+        if streaming:
+            return self.fs.open(self.path, "rb", block_size=0)
+        return self.fs.open(self.path, "rb", block_size=64 << 10, cache_type="none")
+
+    def read_bytes(self, start=0, stop=None):
+        self._check_open()
+        stop = self.nbytes if stop is None else stop
+        if type(start) is not int or type(stop) is not int or not 0 <= start <= stop <= self.nbytes:
+            raise ValueError("Byte interval must satisfy 0 <= start <= stop <= nbytes")
+        if stop - start > MAX_READ_BYTES:
+            raise ValueError("read_bytes exceeds 16 MiB; use streaming download")
+        if start == stop:
+            return b""
+        # Previews start at zero. Streaming avoids HTTP range responses that
+        # lie about their length causing an unbounded response-body allocation.
+        with self._stream(streaming=start == 0) as stream:
+            if start:
+                stream.seek(start)
+            data = bytearray()
+            while len(data) < stop - start:
+                remaining = stop - start - len(data)
+                requested = min(TRANSFER_BYTES, remaining)
+                part = stream.read(requested)
+                if not part:
+                    raise OSError("File changed or returned a short read; reopen the source")
+                if len(part) > requested:
+                    raise OSError("Filesystem returned more bytes than requested")
+                data.extend(part)
+        return bytes(data)
+
+    def download(self, destination, *, overwrite=False, progress=None, cancel=None):
+        """Stream an explicit copy with atomic publication, no overwrite by default."""
+        self._check_open()
+        if not isinstance(overwrite, bool):
+            raise TypeError("overwrite must be a bool")
+        if (progress is not None and not callable(progress)) or (
+            cancel is not None and not callable(cancel)
+        ):
+            raise TypeError("progress and cancel must be callable or None")
+        destination = Path(destination).absolute()
+        if not overwrite and destination.exists():
+            raise FileExistsError(destination)
+        if self.fs is None and destination.exists() and os.path.samefile(self.path, destination):
+            raise ValueError("Destination must differ from the source file")
+        fd, temporary = tempfile.mkstemp(prefix=".b2view-download-", dir=destination.parent)
+        try:
+            with os.fdopen(fd, "wb") as output, self._stream(streaming=True) as source:
+                done = 0
+                while done < self.nbytes:
+                    if cancel is not None and cancel():
+                        raise InterruptedError("File operation cancelled")
+                    requested = min(TRANSFER_BYTES, self.nbytes - done)
+                    data = source.read(requested)
+                    if not data:
+                        raise OSError("File changed or returned a short read; reopen the source")
+                    if len(data) > requested:
+                        raise OSError("Filesystem returned more bytes than requested")
+                    output.write(data)
+                    done += len(data)
+                    if progress is not None:
+                        progress(done, self.nbytes)
+                if source.read(1):
+                    raise OSError("File size changed; reopen the source")
+                output.flush()
+                os.fsync(output.fileno())
+            self._check_open()
+            if cancel is not None and cancel():
+                raise InterruptedError("File operation cancelled")
+            _publish_download(temporary, destination, overwrite)
+            return str(destination)
+        finally:
+            Path(temporary).unlink(missing_ok=True)
+
+    def close(self):
+        self._closed = True
diff --git a/src/blosc2/b2view/render.py b/src/blosc2/b2view/render.py
index e304aa6e1..c956d7f72 100644
--- a/src/blosc2/b2view/render.py
+++ b/src/blosc2/b2view/render.py
@@ -17,7 +17,7 @@ def make_metadata_renderable(info, *, show_path=True):
     table.add_column("key", style="bold cyan", no_wrap=True)
     table.add_column("value")
     if show_path:
-        table.add_row("path", info.path)
+        table.add_row("path", info.display_path or info.path)
     table.add_row("kind", info.kind)
     for key, value in info.metadata.items():
         table.add_row(str(key), _format_metadata_value(value))
@@ -34,13 +34,36 @@ def make_preview_renderables(preview: Any):
     """Return ``(header, body)`` Rich renderables for a preview object.
 
     CTable previews get a separate header renderable so the UI can keep column
-    titles fixed while only the row body scrolls. Other preview kinds return
-    ``None`` for the header.
+    titles fixed while only the row body scrolls. File previews use the header
+    for notices/actions or a fallback status; other kinds may return ``None``.
     """
     from rich.pretty import Pretty
     from rich.table import Table
     from rich.text import Text
 
+    if isinstance(preview, dict) and "notebook_cells" in preview:
+        return _notebook_renderables(preview)
+
+    if isinstance(preview, dict) and "preview_status" in preview:
+        body = str(preview["message"])
+        if preview.get("actions"):
+            body += "\n\n" + preview["actions"]
+        return Text(preview["preview_status"]), Text(body)
+
+    if isinstance(preview, dict) and "file_text" in preview:
+        from rich.markdown import Markdown
+
+        body = (
+            Markdown(preview["file_text"], hyperlinks=False)
+            if preview.get("markdown")
+            else Text(preview["file_text"])
+        )
+        return Text(
+            " · ".join(part for part in (preview.get("notice"), preview.get("message")) if part)
+        ), body
+    if isinstance(preview, dict) and "file_image" in preview:
+        return None, Text(preview["message"])
+
     if isinstance(preview, np.ndarray):
         return None, Text(np.array2string(preview, threshold=200, edgeitems=5), no_wrap=False)
 
@@ -63,6 +86,33 @@ def make_preview_renderables(preview: Any):
     return None, Pretty(preview)
 
 
+def _notebook_renderables(preview):
+    from rich.console import Group
+    from rich.text import Text
+
+    cells = [notebook_cell_renderable(cell, preview["language"]) for cell in preview["notebook_cells"]]
+    header = Text(" · ".join(part for part in (preview.get("notice"), preview["message"]) if part))
+    return header, Group(*cells) if cells else Text("Empty notebook.")
+
+
+def notebook_cell_renderable(cell, language):
+    """Render one passive cell, shared by the text and inline-image layouts."""
+    from rich.console import Group
+    from rich.markdown import Markdown
+    from rich.panel import Panel
+    from rich.syntax import Syntax
+    from rich.text import Text
+
+    if cell["kind"] == "markdown":
+        source = Markdown(cell["source"], hyperlinks=False)
+    elif cell["kind"] == "code":
+        source = Syntax(cell["source"], language, word_wrap=True)
+    else:
+        source = Text(cell["source"])
+    body = Group(source, Text(cell["output"])) if cell["output"] else source
+    return Panel(body, title=Text(f"Cell {cell['index']} · {cell['kind']}"))
+
+
 def _make_ctable_header(preview: dict[str, Any], widths: dict[str, int]):
     from rich.align import Align
     from rich.console import Group
diff --git a/src/blosc2/b2view/search_screen.py b/src/blosc2/b2view/search_screen.py
new file mode 100644
index 000000000..2c94025cb
--- /dev/null
+++ b/src/blosc2/b2view/search_screen.py
@@ -0,0 +1,160 @@
+"""A non-destructive discovered-node filter and explicit recursive search."""
+
+import threading
+from dataclasses import dataclass
+from typing import ClassVar
+
+from rich.text import Text
+from textual import work
+from textual.containers import Horizontal, Vertical
+from textual.screen import ModalScreen
+from textual.widgets import Button, Input, Static, Tree
+
+from blosc2.b2view.file_preview import safe_text
+from blosc2.b2view.tree_search import MAX_DEPTH, MAX_DIRECTORIES, MAX_NODES, matching_nodes, search_tree
+
+
+@dataclass
+class SearchSelection:
+    path: str
+
+
+class TreeSearchScreen(ModalScreen):
+    """Leave the main tree's selection/expansion untouched unless a result is chosen."""
+
+    DEFAULT_CSS = """
+    TreeSearchScreen { align: center middle; }
+    #tree-search-dialog { width: 85%; height: 85%; border: round $accent; padding: 1 2; }
+    #tree-search-status { height: auto; }
+    #tree-search-results { height: 1fr; }
+    #tree-search-buttons { height: 3; }
+    """
+    BINDINGS: ClassVar = [("escape", "cancel", "Close")]
+
+    def __init__(self, browser, listings, session):
+        super().__init__()
+        self.browser = browser
+        self.listings = dict(listings)
+        self.session = session
+        self.cancelled = threading.Event()
+        self.searching = False
+        self.mode = "Discovered nodes only (no network requests)"
+        self.matches = set()
+
+    def compose(self):
+        with Vertical(id="tree-search-dialog"):
+            yield Static("Find by name/path — case-insensitive substring", markup=False)
+            yield Input(placeholder="Filter discovered nodes…", id="tree-search-query")
+            yield Static(self.mode, id="tree-search-status", markup=False)
+            yield Tree("Matches", id="tree-search-results")
+            with Horizontal(id="tree-search-buttons"):
+                yield Button("Search recursively", id="tree-search-recursive", variant="primary")
+                yield Button("Close", id="tree-search-close")
+
+    def on_mount(self):
+        self.query_one(Input).focus()
+        self._filter()
+
+    def on_input_changed(self, event: Input.Changed):
+        self._filter()
+
+    def _filter(self):
+        if not self.is_mounted:
+            return
+        matches = matching_nodes(self.listings, self.query_one(Input).value)
+        self.matches = {node.path for node in matches}
+        visible = matches[:500]
+        tree = self.query_one(Tree)
+        tree.clear()
+        ancestors = {"/": tree.root}
+        for node in visible:
+            parts = node.path.strip("/").split("/")
+            path = ""
+            parent = tree.root
+            for part in parts:
+                path += "/" + part
+                if path not in ancestors:
+                    ancestors[path] = parent.add(Text(safe_text(part)), data=path)
+                parent = ancestors[path]
+        for node in ancestors.values():
+            node.allow_expand = bool(node.children)
+            node.expand()
+        count = f"{len(matches)} matches"
+        if len(visible) < len(matches):
+            count += "; showing first 500 — refine the filter"
+        self.query_one("#tree-search-status", Static).update(f"{self.mode}\n{count}")
+
+    def on_input_submitted(self):
+        self.query_one(Tree).focus()
+
+    def on_tree_node_selected(self, event: Tree.NodeSelected):
+        event.stop()
+        if event.node.data in self.matches and not self.searching:
+            self.dismiss(SearchSelection(event.node.data))
+
+    def on_tree_node_expanded(self, event: Tree.NodeExpanded):
+        # This is a filtered mirror, not the app's navigation tree. Expanding
+        # its ancestors must never trigger background discovery in the app.
+        event.stop()
+
+    def on_button_pressed(self, event: Button.Pressed):
+        if event.button.id == "tree-search-close":
+            self.action_cancel()
+        elif self.searching:
+            self.cancelled.set()
+        else:
+            self.cancelled.clear()
+            self.searching = True
+            event.button.label = "Cancel search"
+            self.mode = f"Searching listings/metadata (limits: {MAX_DIRECTORIES} directories, {MAX_NODES:,} nodes, depth {MAX_DEPTH})"
+            self._filter()
+            self._search()
+
+    def _obsolete(self):
+        return (
+            self.cancelled.is_set()
+            or self.app._closing
+            or self.session != self.app._remote_session
+            or self.browser is not self.app.browser
+        )
+
+    @work(thread=True, exit_on_error=False)
+    def _search(self):
+        def progress(report):
+            # Avoid rebuilding hundreds of result-tree nodes for every fast
+            # directory listing. Always deliver the final complete snapshot.
+            if report.directories != 1 and report.directories % 10:
+                return
+            self.app.call_from_thread(
+                self._update_search,
+                dict(report.listings),
+                f"Searching… {report.directories} directories",
+                False,
+            )
+
+        report = search_tree(self.browser, self.listings, cancel=self._obsolete, progress=progress)
+        message = f"{report.status}: {report.directories} directories; {len(report.errors)} listing errors"
+        if report.errors:
+            message += "\n" + self.app._error_message(report.errors[-1][1])
+        self.app.call_from_thread(self._update_search, report.listings, message, True)
+
+    def _update_search(self, listings, message, finished):
+        if (
+            not self.is_mounted
+            or self.session != self.app._remote_session
+            or self.browser is not self.app.browser
+        ):
+            return
+        self.listings = listings
+        self.mode = message
+        if finished:
+            self.searching = False
+            self.query_one("#tree-search-recursive", Button).label = "Search recursively"
+        self._filter()
+
+    def action_cancel(self):
+        self.cancelled.set()
+        self.dismiss(None)
+
+    def on_unmount(self):
+        self.cancelled.set()
diff --git a/src/blosc2/b2view/tree_search.py b/src/blosc2/b2view/tree_search.py
new file mode 100644
index 000000000..6053442ec
--- /dev/null
+++ b/src/blosc2/b2view/tree_search.py
@@ -0,0 +1,90 @@
+"""Listing-only searches shared by all b2view tree backends."""
+
+from collections import deque
+from dataclasses import dataclass, field
+
+MAX_DIRECTORIES = 200
+MAX_NODES = 10_000
+MAX_DEPTH = 12
+
+
+def matching_nodes(listings, query):
+    """Case-insensitive path matches over discovered nodes; performs no I/O."""
+    query = query.casefold().strip()
+    nodes = {node.path: node for children in listings.values() for node in children}
+    return sorted((node for node in nodes.values() if query in node.path.casefold()), key=lambda n: n.path)
+
+
+@dataclass
+class SearchReport:
+    listings: dict = field(default_factory=dict)
+    errors: list = field(default_factory=list)
+    directories: int = 0
+    status: str = "Complete"
+
+
+def _enqueue_children(queue, children, depth, max_depth):
+    groups = [node.path for node in children if node.has_children]
+    if depth >= max_depth:
+        return bool(groups)
+    queue.extend((path, depth + 1) for path in groups)
+    return False
+
+
+def search_tree(
+    browser,
+    known,
+    *,
+    cancel,
+    progress=None,
+    max_directories=MAX_DIRECTORIES,
+    max_nodes=MAX_NODES,
+    max_depth=MAX_DEPTH,
+):
+    """Breadth-first discovery without previewing files, arrays or tables.
+
+    Known listings are reused. Limits are checked between directory listings;
+    a backend's final indivisible listing may exceed the node budget.
+    """
+    report = SearchReport(dict(known))
+    queue = deque([("/", 0)])
+    visited = set()
+    depth_limited = False
+    while queue:
+        if cancel():
+            report.status = "Cancelled"
+            break
+        path, depth = queue.popleft()
+        if path in visited:
+            continue
+        if report.directories >= max_directories:
+            report.status = "Directory limit reached"
+            break
+        visited.add(path)
+        report.directories += 1
+        try:
+            if path not in report.listings:
+                with browser.io_lock:
+                    if cancel():
+                        report.status = "Cancelled"
+                        break
+                    children = browser.list_children(path)
+                if cancel():
+                    report.status = "Cancelled"
+                    break
+                report.listings[path] = children
+            children = report.listings[path]
+            if progress is not None:
+                progress(report)
+            if len({node.path for values in report.listings.values() for node in values}) >= max_nodes:
+                report.status = "Node limit reached"
+                break
+            depth_limited |= _enqueue_children(queue, children, depth, max_depth)
+        except Exception as error:
+            report.errors.append((path, error))
+    else:
+        if depth_limited:
+            report.status = "Depth limit reached"
+        elif report.errors:
+            report.status = "Completed with listing errors"
+    return report
diff --git a/src/blosc2/c2array.py b/src/blosc2/c2array.py
index 59c12d1c2..4567e00f7 100644
--- a/src/blosc2/c2array.py
+++ b/src/blosc2/c2array.py
@@ -7,6 +7,7 @@
 
 from __future__ import annotations
 
+import ast
 import asyncio
 import atexit
 import json
@@ -1607,7 +1608,13 @@ def blocks(self) -> tuple[int]:
     @property
     def dtype(self) -> np.dtype:
         """The dtype of the remote array"""
-        return np.dtype(self.meta["dtype"])
+        dtype = self.meta["dtype"]
+        try:
+            return np.dtype(dtype)
+        except (TypeError, ValueError):
+            # Caterva2 sends structured/subarray descriptors as their Python repr,
+            # just like the b2nd metalayer. Parse literals, never executable code.
+            return np.dtype(ast.literal_eval(dtype))
 
     @property
     def cparams(self) -> blosc2.CParams:
diff --git a/src/blosc2/caterva2_url.py b/src/blosc2/caterva2_url.py
new file mode 100644
index 000000000..1699e78ff
--- /dev/null
+++ b/src/blosc2/caterva2_url.py
@@ -0,0 +1,199 @@
+"""Recognition of Caterva2 service URLs, separate from source format detection."""
+
+from urllib.parse import unquote, urlsplit, urlunsplit
+
+import blosc2
+
+
+def validate_service_url(value):
+    """Validate a service URL without silently normalizing unsafe components."""
+    if not isinstance(value, str) or not value.startswith(("http://", "https://")):
+        raise ValueError("Caterva2 service URLs require http:// or https://")
+    if any(char.isspace() or ord(char) < 32 or ord(char) == 127 for char in value) or "\\" in value:
+        raise ValueError("Unsafe Caterva2 service URL")
+    parsed = urlsplit(value)
+    if (
+        not parsed.netloc
+        or not parsed.hostname
+        or parsed.username is not None
+        or parsed.password is not None
+    ):
+        raise ValueError("Caterva2 service URL requires an authority without userinfo")
+    _ = parsed.port
+    if parsed.query or parsed.fragment or "::" in parsed.path:
+        raise ValueError("Caterva2 service URLs do not support queries, fragments, or selectors")
+    for component in parsed.path.split("/"):
+        decoded = decode_service_component(component)
+        if (
+            decoded in {".", ".."}
+            or any(c in decoded for c in "/\\%?#")
+            or any(ord(c) < 32 or ord(c) == 127 for c in decoded)
+        ):
+            raise ValueError("Unsafe Caterva2 URL path component")
+    return parsed
+
+
+def decode_service_component(component):
+    """Decode exactly once, rejecting malformed escapes and invalid UTF-8."""
+    import re
+
+    if re.search(r"%(?![0-9a-fA-F]{2})", component):
+        raise ValueError("Malformed URL escape")
+    return unquote(component, errors="strict")
+
+
+def caterva2_urlpath(value):
+    """Return a URLPath for an @-root service URL, or None for an ordinary URL.
+
+    This function never makes a network request. Use an explicit fsspec override
+    when an ordinary HTTP source happens to have an @-prefixed path component.
+    """
+    if not isinstance(value, str) or not value.startswith(("http://", "https://")):
+        return None
+    parsed = urlsplit(value)
+    components = parsed.path.split("/")
+    marker = next(
+        (i for i, component in enumerate(components) if decode_service_component(component).startswith("@")),
+        None,
+    )
+    if marker is None:
+        return None
+    validate_service_url(value)
+    logical = [decode_service_component(component) for component in components[marker:]]
+    if logical[-1] == "":
+        logical.pop()
+    if not logical or logical[0] == "@" or any(not component for component in logical):
+        raise ValueError("Caterva2 URL requires a root and nonempty dataset components")
+    base = urlunsplit((parsed.scheme, parsed.netloc, "/".join(components[:marker]), "", ""))
+    return blosc2.URLPath("/".join(logical), urlbase=base)
+
+
+def service_probe_candidate(value):
+    """Whether an HTTP URL is ambiguous rather than a recognized data source."""
+    if not isinstance(value, str) or not value.startswith(("http://", "https://")):
+        return False
+    parsed = urlsplit(value)
+    if parsed.query or parsed.fragment or "::" in parsed.path:
+        return False
+    suffixes = (
+        ".b2nd",
+        ".b2",
+        ".b2t",
+        ".b2o",
+        ".b2z",
+        ".b2d",
+        ".b2f",
+        ".b2frame",
+        ".b2b",
+        ".b2e",
+        ".h5",
+        ".hdf5",
+        ".zarr",
+        ".parquet",
+    )
+    return not any(
+        decode_service_component(part).lower().endswith(suffixes) for part in parsed.path.split("/")
+    )
+
+
+def validate_roots(roots):
+    """Validate the Caterva2 roots mapping without assuming a root name prefix."""
+    if not isinstance(roots, dict) or len(roots) > 1000:
+        raise ValueError("Invalid Caterva2 roots response")
+    for name, metadata in roots.items():
+        if (
+            not isinstance(name, str)
+            or not name
+            or name in {".", ".."}
+            or any(c in name for c in "/\\:%?#")
+            or any(ord(c) < 32 or ord(c) == 127 for c in name)
+            or not isinstance(metadata, dict)
+            or metadata.get("name", name) != name
+        ):
+            raise ValueError("Invalid Caterva2 root entry")
+    return roots
+
+
+def discovery_auth_token(value, *, required=False, auth_token=None):
+    """Scope implicit automatic-discovery credentials to the configured origin."""
+    if auth_token is not None or required:
+        return auth_token
+    from blosc2.c2array import _server_data
+
+    def origin(url):
+        parsed = urlsplit(url)
+        return parsed.scheme, parsed.hostname, parsed.port or (443 if parsed.scheme == "https" else 80)
+
+    configured = _server_data["urlbase"]
+    if configured and origin(value) == origin(configured):
+        return _server_data["auth_token"]
+    return ""  # Explicitly suppress _auth_headers' ambient-token inheritance.
+
+
+def discover_service(value, *, required=False, auth_token=None):
+    """Probe api/roots with bounded bytes, time, and same-origin redirects.
+
+    Return a validated roots mapping or None for a conclusively non-service
+    response. Authentication, connectivity, and server failures are preserved.
+    """
+    import time
+
+    from blosc2.c2array import _auth_headers, _server_url, _sync_client
+
+    parsed = validate_service_url(value)
+    auth_token = discovery_auth_token(value, required=required, auth_token=auth_token)
+    url = _server_url(value.rstrip("/"), "api/roots")
+    client = _sync_client()
+    headers = dict(_auth_headers(auth_token) or {})
+    headers["Accept-Encoding"] = "identity"
+    deadline = time.monotonic() + 3
+    for _ in range(4):
+        remaining = deadline - time.monotonic()
+        if remaining <= 0:
+            raise TimeoutError("Caterva2 service discovery exceeded 3 seconds")
+        with client.stream(
+            "GET", url, headers=headers, timeout=remaining, follow_redirects=False
+        ) as response:
+            if response.status_code in {301, 302, 303, 307, 308}:
+                from urllib.parse import urljoin
+
+                target = urljoin(url, response.headers.get("location", ""))
+                redirect = urlsplit(target)
+                if (
+                    redirect.scheme,
+                    redirect.hostname,
+                    redirect.port or (443 if redirect.scheme == "https" else 80),
+                ) != (
+                    parsed.scheme,
+                    parsed.hostname,
+                    parsed.port or (443 if parsed.scheme == "https" else 80),
+                ):
+                    raise ValueError("Caterva2 discovery cannot redirect credentials to another origin")
+                if redirect.username is not None or redirect.password is not None:
+                    raise ValueError("Unsafe Caterva2 discovery redirect")
+                url = target
+                continue
+            if response.status_code in {404, 405}:
+                if required:
+                    response.raise_for_status()
+                return None
+            response.raise_for_status()
+            # Reject before iter_bytes can decompress an untrusted response.
+            if response.headers.get("content-encoding", "identity").strip().lower() != "identity":
+                raise ValueError("Encoded Caterva2 roots responses are unsupported")
+            payload = bytearray()
+            for chunk in response.iter_bytes():
+                if time.monotonic() > deadline:
+                    raise TimeoutError("Caterva2 service discovery exceeded 3 seconds")
+                if len(payload) + len(chunk) > 1 << 20:
+                    raise ValueError("Caterva2 roots response exceeds 1 MiB")
+                payload.extend(chunk)
+            import json
+
+            try:
+                return validate_roots(json.loads(payload))
+            except (ValueError, TypeError) as error:
+                if required:
+                    raise ValueError("Invalid Caterva2 roots response") from error
+                return None
+    raise ValueError("Too many Caterva2 discovery redirects")
diff --git a/src/blosc2/ctable.py b/src/blosc2/ctable.py
index 5aec4aba2..bdaa01a5c 100644
--- a/src/blosc2/ctable.py
+++ b/src/blosc2/ctable.py
@@ -7810,8 +7810,22 @@ def take(self, indices, /) -> CTable:
         returned table preserves the order of ``indices`` and any duplicates,
         unlike mask-based views.
         """
+        from blosc2.ctable_storage import _AllValidRows
+        from blosc2.remote_parquet import ParquetTableStorage
+
         logical_pos = self._normalize_row_take_indices(indices, self.nrows)
-        physical_pos = self._live_positions_from_valid_rows_chunks()[logical_pos]
+        parquet = isinstance(self._remote_read_storage(), ParquetTableStorage)
+        # A Parquet dictionary is discovered by reading row groups, not stored
+        # globally in its footer. Empty schema frames must not touch columns.
+        if parquet and not len(logical_pos):
+            return self._empty_copy(capacity=0)
+        if (
+            isinstance(self._valid_rows, _AllValidRows)
+            and getattr(self, "_cached_live_positions", None) is None
+        ):
+            physical_pos = logical_pos
+        else:
+            physical_pos = self._live_positions_from_valid_rows_chunks()[logical_pos]
         n = len(physical_pos)
 
         result = self._empty_copy(capacity=n)
@@ -7825,14 +7839,20 @@ def take(self, indices, /) -> CTable:
                 result._cols[col_name].extend(arr[int(pos)] for pos in physical_pos)
                 result._cols[col_name].flush()
             elif self._is_dictionary_column(col):
-                for v in arr.dictionary:
-                    result._cols[col_name].encode(v)
-                codes = arr.codes
-                result._cols[col_name].codes[:n] = (
-                    codes._take_numpy(physical_pos, axis=0)
-                    if hasattr(codes, "_take_numpy")
-                    else codes[physical_pos]
-                )
+                if parquet:
+                    # Re-encode selected values rather than constructing a
+                    # global dictionary by scanning every Parquet row group.
+                    target = result._cols[col_name]
+                    target.codes[:n] = target.encode_batch(arr[physical_pos])
+                else:
+                    for v in arr.dictionary:
+                        result._cols[col_name].encode(v)
+                    codes = arr.codes
+                    result._cols[col_name].codes[:n] = (
+                        codes._take_numpy(physical_pos, axis=0)
+                        if hasattr(codes, "_take_numpy")
+                        else codes[physical_pos]
+                    )
             else:
                 result._cols[col_name][:n] = (
                     arr._take_numpy(physical_pos, axis=0)
diff --git a/src/blosc2/proxy_source.py b/src/blosc2/proxy_source.py
index b138de1b5..46ac63127 100644
--- a/src/blosc2/proxy_source.py
+++ b/src/blosc2/proxy_source.py
@@ -713,6 +713,111 @@ def _chunk_extents(offsets: np.ndarray, header: list) -> np.ndarray:
     return np.minimum(extents, cap) if header[8] else extents
 
 
+class ByteRangeSChunkSource:
+    """Bounded contiguous-frame metadata/chunks for passive document readers.
+
+    Unlike array sources, this never reconstructs objects from metalayers and
+    reads each chunk header before its payload. ``read_range`` must return exact
+    ranges and refuse unbounded transport fallbacks.
+    """
+
+    def __init__(self, read_range, size):
+        self.read_range = read_range
+        self.size = size
+        self._offsets = None
+        self._last_header = None
+        head = self._read(0, 15)
+        header_len = struct.unpack_from(">i", head, 11)[0]
+        if not 16 <= header_len <= 1 << 20:
+            raise ValueError("Document frame header exceeds metadata limits")
+        raw, header, _ = _read_frame_header(self._read, head=head)
+        if len(header) != 14 or header[2] != size or header[11]:
+            raise ValueError("Document requires a fixed-chunk contiguous SChunk frame")
+        self._header = header
+        self.nbytes, self.cbytes, self.chunksize = header[4], header[5], header[8]
+        if any(type(value) is not int or value < 0 for value in (self.nbytes, self.cbytes)):
+            raise ValueError("Invalid document frame sizes")
+        if self.nbytes and (type(self.chunksize) is not int or self.chunksize <= 0):
+            raise ValueError("Document requires fixed-size chunks")
+        self.chunksize = max(self.chunksize, 0)
+        self.nchunks = (self.nbytes + self.chunksize - 1) // self.chunksize if self.nbytes else 0
+        if self.nchunks * 8 > 8 << 20:
+            raise ValueError("Document chunk index exceeds 8 MiB metadata limit")
+        # Read only metalayer names, never interpret serialized payloads.
+        names = header[13][1]
+        self.meta = {name.decode("utf-8"): None for name in names}
+        if "b2nd" in self.meta:
+            raise ValueError("Document carrier must be an SChunk byte stream, not an array or table")
+        self._index_pos = header_len + self.cbytes
+        if self._index_pos > size:
+            raise ValueError("Invalid document frame extent")
+
+    def _read(self, offset, size):
+        if not 0 <= size <= (8 << 20) or not 0 <= offset <= self.size - size:
+            raise ValueError("Document frame metadata read exceeds bounds")
+        data = self.read_range(offset, size)
+        if len(data) != size:
+            raise ValueError("Short document frame range read")
+        return data
+
+    def _chunk_offset(self, index):
+        if self._offsets is None:
+            if self.nchunks:
+                head = self._read(self._index_pos, 16)
+                nbytes, _, cbytes = struct.unpack_from("<III", head, 4)
+                if nbytes != self.nchunks * 8 or not 16 <= cbytes <= 8 << 20:
+                    raise ValueError("Document chunk index exceeds metadata bounds")
+                chunk = self._read(self._index_pos, cbytes)
+                if chunk[:16] != head:
+                    raise ValueError("Document chunk index changed during reading")
+                decoded = blosc2.decompress2(chunk)
+                if len(decoded) != nbytes:
+                    raise ValueError("Document chunk index has an invalid decoded length")
+                offsets = np.frombuffer(decoded, dtype="<i8")
+                self._offsets = np.where(offsets >= 0, offsets + self._header[1], offsets)
+            else:
+                self._offsets = np.empty(0, dtype=np.int64)
+            if len(self._offsets) != self.nchunks:
+                raise ValueError("Document chunk index does not match frame metadata")
+        offset = int(self._offsets[index])
+        if offset >= 0 and not self._header[1] <= offset <= self._index_pos - 32:
+            raise ValueError("Document chunk offset is outside the payload")
+        return offset
+
+    def get_lazychunk(self, index):
+        offset = self._chunk_offset(index)
+        if offset < 0:
+            kind = _special_kind(offset)
+            if kind != _SPECIAL_ZERO:
+                raise ValueError("Document contains an unsupported special chunk")
+            size = min(self.chunksize, self.nbytes - index * self.chunksize)
+            header = bytearray(blosc2.compress2(bytes(128), typesize=1))
+            struct.pack_into("<III", header, 4, size, size, 32)
+            header = bytes(header)
+        else:
+            header = self._read(offset, 32)
+        self._last_header = index, offset, header
+        return header
+
+    def get_chunk(self, index):
+        if self._last_header is None or self._last_header[0] != index:
+            self.get_lazychunk(index)
+        _, offset, header = self._last_header
+        if offset < 0:
+            return header
+        cbytes = struct.unpack_from("<I", header, 12)[0]
+        from blosc2.remote_file import MAX_COMPRESSED_CHUNK, MAX_DECODED_CHUNK
+
+        if struct.unpack_from("<I", header, 4)[0] > MAX_DECODED_CHUNK:
+            raise ValueError("Document chunk exceeds decoded limit")
+        if not 32 <= cbytes <= MAX_COMPRESSED_CHUNK or offset + cbytes > self._index_pos:
+            raise ValueError("Document chunk exceeds compressed bounds")
+        data = self.read_range(offset, cbytes)
+        if len(data) != cbytes or data[:32] != header:
+            raise ValueError("Document changed or returned a short chunk")
+        return data
+
+
 class ByteRangeNDSource(ProxyNDSource):
     """A :ref:`Proxy` source that serves parts of a remote Blosc2 frame.
 
diff --git a/src/blosc2/remote_file.py b/src/blosc2/remote_file.py
new file mode 100644
index 000000000..8d19b2804
--- /dev/null
+++ b/src/blosc2/remote_file.py
@@ -0,0 +1,294 @@
+"""Read-only Caterva2 SChunk byte streams, not array or object deserialization."""
+
+import hashlib
+import os
+import struct
+import tempfile
+import time
+import weakref
+from pathlib import Path
+
+import blosc2
+from blosc2.remote_array import RemoteMetadataMapping
+from blosc2.remote_object import RemoteObject
+
+MAX_COMPRESSED_CHUNK = 32 << 20
+MAX_DECODED_CHUNK = 256 << 20
+MAX_READ_BYTES = 16 << 20
+
+
+def validate_file_metadata(info):
+    """Accept regular fixed-size SChunks; reject ambiguous/variable-length layouts."""
+    for name in ("nbytes", "cbytes", "nchunks", "chunksize"):
+        value = info.get(name)
+        if type(value) is not int or value < 0:
+            raise ValueError(f"Invalid Caterva2 file {name}")
+    size, chunk = info["nbytes"], info["chunksize"]
+    if (chunk == 0 and size) or info["nchunks"] != ((size + chunk - 1) // chunk if chunk else 0):
+        raise ValueError("Caterva2 file requires a fixed-chunk byte stream")
+    params = info.get("cparams")
+    if not isinstance(params, dict) or type(params.get("typesize")) is not int or params["typesize"] <= 0:
+        raise ValueError("Invalid Caterva2 file compression metadata")
+    return {key: info[key] for key in ("nbytes", "cbytes", "nchunks", "chunksize", "cparams")}
+
+
+class RemoteFile(RemoteObject):
+    """A lazy, read-only Caterva2 byte stream.
+
+    ``read_bytes(start, stop)`` returns original bytes (at most 16 MiB per call).
+    ``download(destination)`` streams original bytes with atomic publication and
+    no overwrite by default. Chunk work is limited to 32 MiB compressed / 256 MiB
+    decoded; oversized or irregular streams require server-side rechunking.
+    Caches and lifetime are shared with the containing RemoteStore owner.
+    """
+
+    @classmethod
+    def _from_owner(cls, owner, path):
+        obj = object.__new__(cls)
+        obj._owner, obj.path = owner, path
+        obj._generation = owner.generation
+        obj._meta = validate_file_metadata(owner.metadata["caterva2_files"][path])
+        owner.acquire()
+        obj._finalizer = weakref.finalize(obj, owner.release)
+        return obj
+
+    def _check_open(self):
+        if not self._finalizer.alive:
+            raise RuntimeError("RemoteFile is closed")
+        if self._generation != self._owner.generation:
+            raise RuntimeError("RemoteFile is stale; reopen after refresh")
+
+    @property
+    def source(self):
+        self._check_open()
+        from blosc2.remote_store import caterva2_source_descriptor
+
+        return caterva2_source_descriptor(blosc2.URLPath(self.path, urlbase=self._owner.caterva2.urlbase))
+
+    @property
+    def name(self):
+        self._check_open()
+        return self.path.rsplit("/", 1)[-1]
+
+    @property
+    def media_type(self):
+        """A filename-based MIME hint, not a guarantee about the payload."""
+        import mimetypes
+
+        return mimetypes.guess_type(self.name)[0]
+
+    @property
+    def nbytes(self):
+        self._check_open()
+        return self._meta["nbytes"]
+
+    @property
+    def cbytes(self):
+        self._check_open()
+        return self._meta["cbytes"]
+
+    @property
+    def chunksize(self):
+        self._check_open()
+        return self._meta["chunksize"]
+
+    @property
+    def nchunks(self):
+        self._check_open()
+        return self._meta["nchunks"]
+
+    @property
+    def attrs(self):
+        self._check_open()
+        return RemoteMetadataMapping(self._owner.attrs.get(self.path, {}))
+
+    @property
+    def traffic(self):
+        self._check_open()
+        return self._owner.traffic
+
+    @property
+    def cache_policy(self):
+        self._check_open()
+        return self._owner.cache_policy
+
+    @property
+    def max_cache_bytes(self):
+        self._check_open()
+        return self._owner.max_cache_bytes
+
+    @property
+    def cache_bytes(self):
+        """Retained bytes for the shared owner, including other leaves."""
+        self._check_open()
+        return self._owner.cache_coordinator.cache_bytes
+
+    @property
+    def metadata_bytes(self):
+        self._check_open()
+        return self._owner.metadata_bytes
+
+    @property
+    def info(self):
+        from blosc2.info import InfoReporter
+
+        return InfoReporter(self)
+
+    @property
+    def info_items(self):
+        self._check_open()
+        return [
+            ("type", "RemoteFile"),
+            ("name", self.name),
+            ("source", self.source),
+            ("nbytes", self.nbytes),
+            ("cbytes", self.cbytes),
+            ("chunksize", self._meta["chunksize"]),
+            ("nchunks", self._meta["nchunks"]),
+            ("cache policy", self.cache_policy),
+            ("cache bytes (owner)", self.cache_bytes),
+        ]
+
+    def _fetch_chunk(self, index, cancel):
+        from blosc2.c2array import _auth_headers, _server_url, _sync_client
+
+        owner = self._owner
+        url = _server_url(owner.caterva2.urlbase, f"api/chunk/{self.path}")
+        client = owner.transport or _sync_client()
+        data = bytearray()
+        deadline = time.monotonic() + 20
+        headers = dict(_auth_headers(owner.caterva2.auth_token) or {})
+        headers["Accept-Encoding"] = "identity"
+        with client.stream(
+            "GET", url, params={"nchunk": index}, headers=headers, timeout=10, follow_redirects=False
+        ) as response:
+            response.raise_for_status()
+            if response.headers.get("content-encoding", "identity") != "identity":
+                raise ValueError("Encoded file chunk responses are unsupported")
+            if int(response.headers.get("content-length", 0)) > MAX_COMPRESSED_CHUNK:
+                raise ValueError(f"File chunk exceeds {MAX_COMPRESSED_CHUNK >> 20} MiB compressed limit")
+            received = 0
+            try:
+                for part in response.iter_bytes():
+                    received += len(part)
+                    if time.monotonic() > deadline:
+                        raise TimeoutError("File chunk transfer exceeded 20 seconds")
+                    if cancel is not None and cancel():
+                        raise InterruptedError("File operation cancelled")
+                    if len(data) + len(part) > MAX_COMPRESSED_CHUNK:
+                        raise ValueError(
+                            f"File chunk exceeds {MAX_COMPRESSED_CHUNK >> 20} MiB compressed limit"
+                        )
+                    data.extend(part)
+            finally:
+                # One HTTP response is one request, regardless of fragmentation.
+                # Also retain bytes already received on failure/cancellation.
+                owner.traffic.charge(received)
+        return bytes(data)
+
+    def _chunk(self, index, cancel=None):
+        from blosc2.remote_store import _Caterva2FrameCache
+
+        self._check_open()
+        if cancel is not None and cancel():
+            raise InterruptedError("File operation cancelled")
+        size = min(self._meta["chunksize"], self.nbytes - index * self._meta["chunksize"])
+        if size > MAX_DECODED_CHUNK:
+            raise ValueError(
+                f"File chunk exceeds {MAX_DECODED_CHUNK >> 20} MiB decoded limit; rechunk on the server"
+            )
+        owner = self._owner
+        key = hashlib.sha256(f"file-chunk:{self.path}:{index}".encode()).hexdigest()
+        cache = None
+        if self.cache_policy is not blosc2.CachePolicy.NONE:
+            if owner.table_frame_cache is None:
+                owner.table_frame_cache = _Caterva2FrameCache(owner)
+            cache = owner.table_frame_cache
+        payload = None if cache is None else cache.get(key, max_bytes=MAX_COMPRESSED_CHUNK)
+        missing = payload is None
+        if payload is None:
+            payload = self._fetch_chunk(index, cancel)
+        if len(payload) < 16 or len(payload) > MAX_COMPRESSED_CHUNK:
+            raise ValueError("Invalid compressed file chunk length")
+        nbytes, _, cbytes = struct.unpack_from("<III", payload, 4)
+        if nbytes != size or cbytes != len(payload):
+            raise ValueError("Compressed file chunk does not match metadata")
+        result = blosc2.decompress(payload)
+        if len(result) != size:
+            raise ValueError("Decoded file chunk does not match metadata")
+        if cache is not None and missing:
+            cache.put(key, payload)
+        return result
+
+    def read_bytes(self, start=0, stop=None):
+        """Read an explicitly bounded byte interval; omitted stop means end of file."""
+        with self._owner.lock:
+            self._check_open()
+            stop = self.nbytes if stop is None else stop
+            if type(start) is not int or type(stop) is not int or not 0 <= start <= stop <= self.nbytes:
+                raise ValueError("Byte interval must satisfy 0 <= start <= stop <= nbytes")
+            if stop - start > MAX_READ_BYTES:
+                raise ValueError("read_bytes exceeds 16 MiB; use streaming download")
+            if start == stop:
+                return b""
+            chunk = self._meta["chunksize"]
+            result = bytearray()
+            for index in range(start // chunk, (stop - 1) // chunk + 1):
+                data = self._chunk(index)
+                result.extend(data[max(0, start - index * chunk) : min(len(data), stop - index * chunk)])
+            return bytes(result)
+
+    def download(self, destination, *, overwrite=False, progress=None, cancel=None):
+        """Stream original bytes, publishing only on success.
+
+        ``progress(done, total)`` and ``cancel()`` run on the caller's thread.
+        A false overwrite uses an atomic hard-link publish to avoid races,
+        or a checked rename on Emscripten's single-threaded virtual filesystem.
+        """
+        self._check_open()
+        if not isinstance(overwrite, bool):
+            raise TypeError("overwrite must be a bool")
+        if (progress is not None and not callable(progress)) or (
+            cancel is not None and not callable(cancel)
+        ):
+            raise TypeError("progress and cancel must be callable or None")
+        destination = Path(destination).absolute()
+        if not overwrite and destination.exists():
+            raise FileExistsError(destination)
+        fd, temporary = tempfile.mkstemp(prefix=".b2view-download-", dir=destination.parent)
+        try:
+            with os.fdopen(fd, "wb") as file:
+                done = 0
+                for index in range(self._meta["nchunks"]):
+                    with self._owner.lock:
+                        data = self._chunk(index, cancel)
+                    file.write(data)
+                    done += len(data)
+                    if progress is not None:
+                        progress(done, self.nbytes)
+                file.flush()
+                os.fsync(file.fileno())
+            self._check_open()
+            if cancel is not None and cancel():
+                raise InterruptedError("File operation cancelled")
+            if overwrite:
+                os.replace(temporary, destination)
+            elif blosc2.IS_WASM:
+                # No hard links on Emscripten. No callbacks/awaits can interleave
+                # a virtual-FS writer between this final check and publication.
+                if os.path.lexists(destination):
+                    raise FileExistsError(destination)
+                os.rename(temporary, destination)
+            else:
+                os.link(temporary, destination)
+            return str(destination)
+        finally:
+            Path(temporary).unlink(missing_ok=True)
+
+    def save(self, *args, **kwargs):
+        raise NotImplementedError(
+            "RemoteFile reference persistence is unsupported; use download for original bytes"
+        )
+
+    def close(self):
+        self._finalizer()
diff --git a/src/blosc2/remote_repository.py b/src/blosc2/remote_repository.py
new file mode 100644
index 000000000..284f8a018
--- /dev/null
+++ b/src/blosc2/remote_repository.py
@@ -0,0 +1,217 @@
+"""A browsing facade for the independent roots of a Caterva2 service."""
+
+import threading
+import weakref
+from pathlib import Path
+
+import blosc2
+from blosc2.caterva2_url import validate_roots, validate_service_url
+from blosc2.info import InfoReporter
+from blosc2.proxy_source import Traffic
+from blosc2.remote_array import CACHE_POLICY_DEFAULT, RemoteMetadataMapping
+from blosc2.remote_store import RemoteNode, RemoteStore
+
+
+def _close_roots(owners, lock, state):
+    with lock:
+        state["users"] -= 1
+        if state["users"]:
+            return
+        for store in owners.values():
+            store.close()
+        owners.clear()
+
+
+class RemoteRepository(RemoteStore):
+    """Read-only, nonpersistent group of Caterva2 roots.
+
+    Returned by ``blosc2.open`` for empty or multi-root services. Root owners
+    open lazily. Cache allowances are **per root**, not a repository-wide bound.
+    Closing this facade leaves previously returned child handles usable.
+    Open a specific root to persist or materialize a selection.
+    """
+
+    def __init__(self, urlbase, roots, *, auth_token=None, **options):
+        validate_service_url(urlbase)
+        self.urlbase = urlbase.rstrip("/")
+        self.roots = dict(validate_roots(roots))
+        self.auth_token = blosc2.c2array._server_data["auth_token"] if auth_token is None else auth_token
+        self.options = dict(options)
+        policy, limit = self._validate_cache_config(
+            self.options.pop("cache_policy", CACHE_POLICY_DEFAULT),
+            self.options.pop("max_cache_bytes", CACHE_POLICY_DEFAULT),
+            self.options.get("cache_dir"),
+        )
+        if self.options.keys() - {"cache_dir"}:
+            raise TypeError("RemoteRepository accepts only cache_dir, cache_policy, and max_cache_bytes")
+        self.options.update(cache_policy=policy, max_cache_bytes=limit)
+        self._lock = threading.RLock()
+        self._roots = {}
+        self._state = {"users": 1}
+        self._traffic = Traffic()
+        self._finalizer = weakref.finalize(self, _close_roots, self._roots, self._lock, self._state)
+        self.is_tree = True
+
+    def _ensure_open(self):
+        if not self._finalizer.alive:
+            raise RuntimeError("RemoteRepository is closed")
+
+    def _resolve(self, path):
+        raise NotImplementedError("Open a repository root before using this RemoteStore operation")
+
+    def _check_open(self):
+        self._ensure_open()
+
+    def _root(self, name):
+        self._ensure_open()
+        if name not in self.roots:
+            raise KeyError(name)
+        if name not in self._roots:
+            options = self.options.copy()
+            if options.get("cache_dir") is not None:
+                # The root owner's existing identity hashing includes the base,
+                # dataset, and authentication scope. Each root gets its own budget.
+                options["cache_dir"] = Path(options["cache_dir"])
+            self._roots[name] = RemoteStore(
+                blosc2.URLPath(name, urlbase=self.urlbase, auth_token=self.auth_token),
+                _traffic=self._traffic,
+                **options,
+            )
+        return self._roots[name]
+
+    def keys(self):
+        with self._lock:
+            self._ensure_open()
+            return sorted(self.roots)
+
+    def __getitem__(self, path):
+        with self._lock:
+            self._ensure_open()
+            if not isinstance(path, str):
+                raise TypeError("RemoteRepository paths must be strings")
+            relative = path.strip("/")
+            if not relative:
+                alias = object.__new__(type(self))
+                alias.__dict__.update(self.__dict__)
+                self._state["users"] += 1
+                alias._finalizer = weakref.finalize(
+                    alias, _close_roots, self._roots, self._lock, self._state
+                )
+                return alias
+            from blosc2.remote_store import RemoteDiscovery
+
+            RemoteDiscovery._validate(relative)
+            name, _, suffix = relative.partition("/")
+            return self._root(name)[suffix]
+
+    def get_info(self, path=""):
+        with self._lock:
+            self._ensure_open()
+            if not isinstance(path, str):
+                raise TypeError("RemoteRepository paths must be strings")
+            relative = path.strip("/")
+            from blosc2.remote_store import RemoteDiscovery
+
+            RemoteDiscovery._validate(relative)
+            if not relative:
+                return RemoteNode("", "group", RemoteMetadataMapping({}))
+            name, _, suffix = relative.partition("/")
+            if name not in self.roots:
+                raise KeyError(name)
+            if not suffix:
+                # Listing the service must not contact all its roots.
+                return RemoteNode(relative, "group", RemoteMetadataMapping(self.roots[name]))
+            info = self._root(name).get_info(suffix)
+            return RemoteNode(relative, info.kind, info.attrs, info.diagnostic, info.catalog_attrs)
+
+    @property
+    def source(self):
+        self._ensure_open()
+        return {"kind": "caterva2_repository", "version": 1, "urlbase": self.urlbase + "/"}
+
+    @property
+    def info(self):
+        return InfoReporter(self)
+
+    @property
+    def info_items(self):
+        return [
+            ("type", type(self).__name__),
+            ("source", self.source),
+            ("roots", self.keys()),
+            ("cache allowance", "per root"),
+        ]
+
+    @property
+    def attrs(self):
+        return self.get_info().attrs
+
+    @property
+    def cache_bytes(self):
+        with self._lock:
+            self._ensure_open()
+            return sum(store.cache_bytes for store in self._roots.values())
+
+    @property
+    def metadata_bytes(self):
+        with self._lock:
+            self._ensure_open()
+            return sum(store.metadata_bytes for store in self._roots.values())
+
+    @property
+    def max_cache_bytes(self):
+        """Configured allowance per root (not a total repository allowance)."""
+        self._ensure_open()
+        return self.options["max_cache_bytes"]
+
+    @property
+    def cache_policy(self):
+        self._ensure_open()
+        return self.options["cache_policy"]
+
+    @property
+    def traffic(self):
+        """Shared counter for opened roots; the initial roots probe is excluded."""
+        self._ensure_open()
+        return self._traffic
+
+    @property
+    def mutable(self):
+        self._ensure_open()
+        return False
+
+    @mutable.setter
+    def mutable(self, value):
+        raise NotImplementedError("Repository persistence is unsupported; select a specific root")
+
+    @property
+    def is_cache_mutable(self):
+        self._ensure_open()
+        return True
+
+    def read_cached(self, path, item=(), *, nchunk=None):
+        with self._lock:
+            self._ensure_open()
+            name, _, suffix = path.strip("/").partition("/")
+            return self._root(name).read_cached(suffix, item, nchunk=nchunk)
+
+    def read_cached_table(self, operation):
+        raise NotImplementedError("Select a specific root for cached table operations")
+
+    def save(self, *args, **kwargs):
+        raise NotImplementedError("Repository persistence is unsupported; save a specific root")
+
+    @classmethod
+    def with_sparse_cache(cls, *args, **kwargs):
+        raise NotImplementedError("Repository shared sparse caching requires selecting a specific root")
+
+    def materialize(self, *args, **kwargs):
+        raise NotImplementedError("Repository materialization is unsupported; select a specific root")
+
+    def refresh(self):
+        raise NotImplementedError(
+            "Reopen the repository to rediscover roots; refresh a specific root separately"
+        )
+
+    def close(self):
+        self._finalizer()
diff --git a/src/blosc2/remote_store.py b/src/blosc2/remote_store.py
index c178e392d..58a52a25d 100644
--- a/src/blosc2/remote_store.py
+++ b/src/blosc2/remote_store.py
@@ -64,7 +64,16 @@ def get_chunk(self, nchunk):
         full = np.zeros(self.chunks, dtype=self.dtype)
         region = tuple(slice(0, item.stop - item.start) for item in selection)
         full[region] = data[...]
-        packed = blosc2.asarray(full, chunks=self.chunks, blocks=self.blocks, cparams=self.cparams)
+        # NumPy expands a top-level subarray dtype into trailing dimensions.
+        # Keep the synthesized chunk's block ordering consistent with that
+        # expanded buffer, without changing the source's logical geometry.
+        inner_shape = self.dtype.subdtype[1] if self.dtype.subdtype is not None else ()
+        packed = blosc2.asarray(
+            full,
+            chunks=(*self.chunks, *inner_shape),
+            blocks=(*self.blocks, *inner_shape),
+            cparams=self.cparams,
+        )
         return packed.schunk.get_chunk(0)
 
 
@@ -107,12 +116,16 @@ def _load_disk_entries(self):
     def _path(self, key):
         return self.folder / f"{key}.cframe"
 
-    def get(self, key):
+    def get(self, key, *, max_bytes=None):
         payload = self._memory.get(key)
         if payload is None and self.folder is not None:
             path = self._path(key)
             if path.is_file():
-                payload = path.read_bytes()
+                if max_bytes is None:
+                    payload = path.read_bytes()
+                else:
+                    with path.open("rb") as file:
+                        payload = file.read(max_bytes + 1)
         if payload is None and key in self._artifact_keys and self.owner.artifact_path is not None:
             member = f"_caterva2_rows/{key}.cframe"
             if self.owner.artifact_offsets is None:
@@ -121,6 +134,8 @@ def get(self, key):
                 with zipfile.ZipFile(self.owner.artifact_path) as archive:
                     payload = archive.read(member)
         if payload is not None:
+            if max_bytes is not None and len(payload) > max_bytes:
+                raise ValueError("Cached file chunk exceeds compressed limit")
             self._cache_lru.pop(key, None)
             self._cache_lru[key] = None
             self.owner.cache_coordinator.touch(self, key)
@@ -332,6 +347,7 @@ class RemoteNode:
     kind: str
     attrs: RemoteMetadataMapping | None
     diagnostic: str | None = None
+    catalog_attrs: RemoteMetadataMapping | None = None
 
 
 def _resolve_hdf5_options(hdf5_index, private_index, source_format):
@@ -368,6 +384,7 @@ def __init__(  # noqa: C901
         _b2z_blob=None,
         _local_source=False,
         _parquet_conversion=None,
+        _root_info=None,
     ):
         self.caterva2 = _caterva2_bound_urlpath(urlpath) if isinstance(urlpath, blosc2.URLPath) else None
         if self.caterva2 is not None:
@@ -416,6 +433,7 @@ def __init__(  # noqa: C901
                 manifest = None  # Rebind legacy metadata/payload to the source digest once.
         self.traffic = _traffic if _traffic is not None else Traffic()
         self.transport = _transport
+        self.root_info = _root_info
         self.nodes = {}
         self.attrs = {}
         self.listed = {}
@@ -460,7 +478,7 @@ def __init__(  # noqa: C901
         self.batch_validator = _batch_validator
         self.filesystem_resolver = _filesystem_resolver
         self.manifest_validator = _manifest_validator
-        self.max_nodes = _max_nodes
+        self.max_nodes = 10000 if self.format == "caterva2" and _max_nodes is None else _max_nodes
         self.metadata_bytes = 0
         self.restoring = False
         self.filesystem = None
@@ -517,7 +535,7 @@ def _restore_manifest(self, manifest):  # noqa: C901
             if (
                 not isinstance(entry, (list, tuple))
                 or len(entry) != 2
-                or entry[0] not in {"group", "ndarray", "ctable", "remote_store", "unsupported"}
+                or entry[0] not in {"group", "ndarray", "ctable", "remote_store", "unsupported", "file"}
             ):
                 raise ValueError("Invalid RemoteStore node")
             self.nodes[path] = tuple(entry)
@@ -533,7 +551,17 @@ def _restore_manifest(self, manifest):  # noqa: C901
             ):
                 raise ValueError("Invalid RemoteStore child list")
         self.attrs = manifest["attrs"]
+        if self.format == "caterva2":
+            for key, (kind, _) in self.nodes.items():
+                if kind == "unsupported":
+                    self.attrs.pop(key, None)
         self.listed = manifest["listed"]
+        if self.format == "caterva2" and self.metadata.get("caterva2_listing_version") != 2:
+            # Earlier snapshots marked all discovered groups as fully listed,
+            # including unexpanded catalog mounts. Retain payload, rediscover
+            # listings rather than permanently restoring false empty groups.
+            self.listed = {}
+            self.metadata["caterva2_listing_version"] = 2
         self.notice = manifest.get("notice")
         if self.format == "b2z" and self.archive is None:
             from blosc2.b2z_source import B2ZArchive
@@ -944,6 +972,13 @@ def _caterva2_kind(info):
             return "ctable"
         if "shape" in info and "dtype" in info:
             return "ndarray"
+        if kind in {"file", "schunk"} or all(
+            key in info for key in ("nbytes", "nchunks", "chunksize", "cparams")
+        ):
+            from blosc2.remote_file import validate_file_metadata
+
+            validate_file_metadata(info)
+            return "file"
         return "unsupported"
 
     def _caterva2_table_metadata(self, path, info):
@@ -979,53 +1014,104 @@ def _caterva2_get(self, endpoint, path):
         response = client.get(url, headers=_auth_headers(self.caterva2.auth_token))
         response.raise_for_status()
         self.traffic.charge(len(response.content))
+        if len(response.content) > 8 << 20:
+            raise ValueError("Caterva2 discovery response exceeds 8 MiB")
         return response.json()
 
     def _open_caterva2(self):
-        root_info = self._caterva2_get("info", self.root)
-        root_kind = self._caterva2_kind(root_info)
-        if root_kind == "ctable":
-            self._add(self.root, "ctable", self._caterva2_table_metadata(self.root, root_info))
-            self.attrs[self.root] = dict(root_info.get("attrs") or {})
-            return
-        if root_kind == "ndarray":
-            self._add(self.root, "ndarray")
-            self.attrs[self.root] = dict(root_info.get("attrs") or {})
-            return
-        if root_kind != "group":
+        self.metadata["caterva2_listing_version"] = 2
+        self._discover_caterva2_node(self.root)
+        if self.nodes[self.root][0] not in {"group", "ctable", "ndarray", "file"}:
             raise ValueError("Caterva2 source root is not an array, group, or CTable")
-        self._add(self.root, "group")
-        self.attrs[self.root] = dict(root_info.get("attrs") or {})
-        leaves = self._caterva2_get("list", self.root)
+
+    def _discover_caterva2_node(self, full):
+        # attrs membership distinguishes actual metadata from structural group
+        # placeholders. An unlisted mount must not be mistaken for an empty group.
+        if full in self.attrs:
+            return
+        try:
+            info = (
+                self.root_info
+                if full == self.root and self.root_info is not None
+                else self._caterva2_get("info", full)
+            )
+        except Exception as error:
+            if getattr(getattr(error, "response", None), "status_code", None) == 404:
+                raise KeyError(full) from error
+            raise
+        if not isinstance(info, dict):
+            raise ValueError("Invalid Caterva2 info response")
+        kind = self._caterva2_kind(info)
+        value = self._caterva2_table_metadata(full, info) if kind == "ctable" else None
+        if kind == "unsupported":
+            value = "Caterva2 object kind is unsupported"
+        attrs = dict(info.get("attrs") or info.get("vlmeta") or {})
+        annotations = dict(info.get("catalog_attrs") or {})
+        # Validate all potentially failing work before changing the registry.
+        # Only this node and its ancestors can change. Do not copy a complete
+        # large catalog for each child's metadata request.
+        ancestors = [full]
+        while ancestors[-1]:
+            ancestors.append(ancestors[-1].rpartition("/")[0])
+        previous = {key: self.nodes.get(key) for key in ancestors}
+        try:
+            self.nodes.pop(full, None)
+            self._add(full, kind, value)
+        except BaseException:
+            for key, old in previous.items():
+                if old is None:
+                    self.nodes.pop(key, None)
+                else:
+                    self.nodes[key] = old
+            raise
+        self.attrs[full] = attrs
+        if kind == "file":
+            from blosc2.remote_file import validate_file_metadata
+
+            self.metadata.setdefault("caterva2_files", {})[full] = validate_file_metadata(info)
+        if annotations:
+            self.metadata.setdefault("catalog_attrs", {})[full] = annotations
+
+    def _list_caterva2(self, full):
+        leaves = self._caterva2_get("list", full)
         if not isinstance(leaves, list) or any(not isinstance(path, str) for path in leaves):
             raise ValueError("Invalid Caterva2 list response")
-        for relative in sorted(set(leaves)):
+        if len(leaves) > 100000:
+            raise ValueError("Caterva2 listing exceeds the 100000-entry discovery limit")
+        children = set()
+        for relative in leaves:
+            if not relative:
+                raise ValueError("Invalid empty Caterva2 list entry")
             self._validate(relative)
-            full = "/".join((self.root, relative))
-            info = self._caterva2_get("info", full)
-            kind = self._caterva2_kind(info)
-            if kind == "ctable":
-                self._add(full, kind, self._caterva2_table_metadata(full, info))
-            elif kind in {"ndarray", "group"}:
-                self._add(full, kind)
-            else:
-                self._add(full, "unsupported", "Caterva2 object kind is unsupported")
-            self.attrs[full] = dict(info.get("attrs") or {})
-        for parent in (path for path, (kind, _) in self.nodes.items() if kind == "group"):
-            self.listed[parent] = sorted(
-                path for path in self.nodes if path != parent and path.rpartition("/")[0] == parent
-            )
+            if any(c in relative for c in "%?#"):
+                raise ValueError("Unsafe Caterva2 list path")
+            children.add(full + "/" + relative.split("/", 1)[0])
+        previous = self.nodes.copy()
+        try:
+            for child in sorted(children):
+                if child not in self.nodes:
+                    self._add(child, "group")
+        except BaseException:
+            self.nodes = previous
+            raise
+        # Only the queried group is complete. Recursive server listings do not
+        # imply that descendant groups/mounts have themselves been listed.
+        self.listed[full] = sorted(children)
 
     def _path(self, path):
         if not isinstance(path, str):
             raise TypeError("RemoteStore paths must be strings")
         relative = path.strip("/")
         self._validate(relative)
+        if self.format == "caterva2" and any(c in relative for c in "%?#"):
+            raise ValueError("Unsafe Caterva2 dataset path")
         return "/".join(p for p in (self.root, relative) if p)
 
     def resolve(self, path):
         """Resolve a relative path without listing a Zarr parent."""
         full = self._path(path)
+        if self.format == "caterva2":
+            self._discover_caterva2_node(full)
         if self.format == "zarr" and (
             full not in self.nodes or (self.nodes[full][0] != "unsupported" and self.nodes[full][1] is None)
         ):
@@ -1046,14 +1132,16 @@ def resolve(self, path):
         return full
 
     def kind(self, path):
-        return self.nodes[self._path(path)][0]
+        return self.nodes[self.resolve(path)][0]
 
     def list_children(self, path):  # noqa: C901
         full = self._path(path)
         if self.nodes[full][0] != "group":
             return []
         if full not in self.listed:
-            if self.format == "zarr":
+            if self.format == "caterva2":
+                self._list_caterva2(full)
+            elif self.format == "zarr":
                 import zarr
 
                 group = self.nodes[full][1]
@@ -1715,6 +1803,10 @@ def save_selection(  # noqa: C901
             metadata = self._export_metadata()
 
             src_desc, nodes, attrs, listed, candidates = self._collect_export_nodes(full_path, include_cache)
+            if any(kind == "file" for kind, _ in nodes.values()):
+                raise NotImplementedError(
+                    "Hierarchy export containing files is unsupported; download files individually"
+                )
 
             staging_dir = tempfile.mkdtemp(prefix="b2z-export-", dir=dest_dir)
             fd, tmp_zip = tempfile.mkstemp(prefix="export-", suffix=".b2z.tmp", dir=dest_dir)
@@ -2094,6 +2186,7 @@ def __init__(  # noqa: C901
         _b2z_blob=None,
         _allow_local_source=False,
         _parquet_conversion=None,
+        _root_info=None,
     ):
         dataset = blosc2.core.resolve_dataset_path(dataset, path)
         caterva2_input = isinstance(urlpath, blosc2.URLPath)
@@ -2209,6 +2302,7 @@ def __init__(  # noqa: C901
                         _b2z_blob=_b2z_blob,
                         _local_source=local_source,
                         _parquet_conversion=_parquet_conversion,
+                        _root_info=_root_info,
                     )
                     break
                 except (KeyError, TypeError, ValueError):
@@ -2881,6 +2975,8 @@ def __getitem__(self, path):
                 return group
             if kind == "ctable":
                 return blosc2.RemoteCTable._from_owner(self._owner, full)
+            if kind == "file":
+                return blosc2.RemoteFile._from_owner(self._owner, full)
             if kind == "unsupported":
                 raise NotImplementedError(f"{path!r}: {value}")
             self._owner.open_source(relative)
@@ -2907,6 +3003,7 @@ def get_info(self, path=""):
                 kind,
                 None if attrs is None else RemoteMetadataMapping(attrs),
                 diagnostic,
+                RemoteMetadataMapping(self._owner.metadata.get("catalog_attrs", {}).get(full, {})),
             )
 
     def kind(self, path=""):
@@ -2932,16 +3029,26 @@ def info_items(self) -> list[tuple[str, object]]:
             entries = {}
             unavailable = []
             pending = [""]
+            listing_errors = (OSError, KeyError, ValueError)
+            if self._owner.format == "caterva2":
+                listing_errors += (blosc2.c2array._httpx().HTTPError,)
             while pending:
-                path, _ = self._resolve(pending.pop())
+                requested = pending.pop()
                 try:
+                    path, _ = self._resolve(requested)
                     children = self._owner.list_children(path)
-                except OSError as exc:
-                    unavailable.append(f"/{path}: {exc}")
+                except listing_errors as exc:
+                    unavailable.append(f"/{requested}: {exc}")
                     continue
                 for child in children:
                     relative = child[len(root) + 1 :] if root else child
-                    kind = self._owner.nodes[child][0]
+                    owner_path = child[len(self._owner.root) + 1 :] if self._owner.root else child
+                    try:
+                        kind = self._owner.nodes[self._owner.resolve(owner_path)][0]
+                    except listing_errors as exc:
+                        unavailable.append(f"/{relative}: {exc}")
+                        entries[relative] = " [unavailable]"
+                        continue
                     entries[relative] = f" [{kind}]"
                     if kind == "group":
                         pending.append(relative)
@@ -3105,6 +3212,10 @@ def save(
     ) -> str:
         """Export the current store or subtree to a portable .b2z reference archive."""
         self._ensure_open()
+        if self._owner.metadata.get("caterva2_files"):
+            raise NotImplementedError(
+                "Caterva2 hierarchy export with ordinary files is unsupported; download files individually"
+            )
         with self._owner.lock:
             _, full = self._resolve("")
             return self._owner.save_selection(
diff --git a/src/blosc2/schema_compiler.py b/src/blosc2/schema_compiler.py
index 745d47f05..a0fef3ff3 100644
--- a/src/blosc2/schema_compiler.py
+++ b/src/blosc2/schema_compiler.py
@@ -418,6 +418,11 @@ def _default_to_json(value: Any) -> Any:
 
 def _default_from_json(value: Any) -> Any:
     """Reverse of :func:`_default_to_json`."""
+    if isinstance(value, dict) and set(value) == {"__float__"}:
+        marker = value["__float__"]
+        if marker not in ("nan", "inf", "-inf"):
+            raise ValueError("Invalid non-finite float metadata tag")
+        return float(marker)
     if isinstance(value, dict) and value.get("__complex__"):
         return complex(value["real"], value["imag"])
     if isinstance(value, dict) and value.get("__bytes__"):
@@ -429,6 +434,9 @@ def spec_from_metadata_dict(data: dict[str, Any]) -> SchemaSpec:
     """Reconstruct one SchemaSpec from serialized metadata."""
     data = dict(data)
     kind = data.pop("kind")
+    # Caterva2 services use explicit tags for values forbidden in strict JSON.
+    # Decode scalar fields here; nested specs recurse through this function.
+    data = {key: _default_from_json(value) for key, value in data.items()}
     if isinstance(data.get("null_value"), dict) and data["null_value"].get("__bytes__"):
         data["null_value"] = _json_to_bytes(data["null_value"])
     if kind == "list":
diff --git a/src/blosc2/schunk.py b/src/blosc2/schunk.py
index e241bd6ea..aa058e044 100644
--- a/src/blosc2/schunk.py
+++ b/src/blosc2/schunk.py
@@ -2159,7 +2159,12 @@ def _open_non_lazy_c2(
         raise NotImplementedError("cache_dir and cache_path for a Caterva2 array require lazy=True")
     if max_concurrency is not None:
         raise NotImplementedError("max_concurrency is only supported with lazy=True")
-    return blosc2.C2Array(urlpath.path, urlbase=urlpath.urlbase, auth_token=urlpath.auth_token)
+    metadata = blosc2.c2array.info(urlpath.path, urlpath.urlbase, auth_token=urlpath.auth_token)
+    if "shape" not in metadata or "dtype" not in metadata:
+        raise NotImplementedError("Caterva2 group/table access requires lazy=True")
+    return blosc2.C2Array(
+        urlpath.path, urlbase=urlpath.urlbase, auth_token=urlpath.auth_token, _meta=metadata
+    )
 
 
 def _open_c2_urlpath(urlpath: blosc2.URLPath, mode: str, offset: int, kwargs: dict):  # noqa: C901
@@ -2197,7 +2202,25 @@ def _open_c2_urlpath(urlpath: blosc2.URLPath, mode: str, offset: int, kwargs: di
         if remote_array_options["assume_immutable"] is not True:
             raise ValueError("shared_cache=True requires assume_immutable=True")
     metadata = blosc2.c2array.info(urlpath.path, urlpath.urlbase, auth_token=urlpath.auth_token)
-    kind = metadata.get("kind")
+    from blosc2.remote_store import RemoteDiscovery
+
+    kind = RemoteDiscovery._caterva2_kind(metadata)
+    if kind == "file":
+        if remote_array_options.get("assume_immutable") is not True:
+            raise ValueError("RemoteFile requires assume_immutable=True")
+        if cache_path is not None or shared_cache or max_concurrency is not None:
+            raise NotImplementedError(
+                "RemoteFile uses cache_dir; shared_cache and max_concurrency are unsupported"
+            )
+        options = {
+            key: remote_array_options[key]
+            for key in ("cache_policy", "max_cache_bytes")
+            if key in remote_array_options
+        }
+        with blosc2.RemoteStore(
+            urlpath, cache_dir=cache_dir, _allow_array_root=True, _root_info=metadata, **options
+        ) as store:
+            return store[""]
     if kind == "group":
         if cache_path is not None:
             raise ValueError("Caterva2 groups use cache_dir, not cache_path")
@@ -2213,6 +2236,7 @@ def _open_c2_urlpath(urlpath: blosc2.URLPath, mode: str, offset: int, kwargs: di
         return blosc2.RemoteStore(
             urlpath,
             cache_dir=cache_dir,
+            _root_info=metadata,
             **store_options,
         )
     if kind == "ctable":
@@ -2777,6 +2801,49 @@ def _validate_shared_cache_request(urlpath, shared_cache, kwargs):
             kwargs["lazy"] = True
 
 
+def _open_service_base(urlpath, roots, mode, offset, shared_cache, kwargs, auth_token=None):
+    """Open one visible root or a lazy repository facade, without a second probe."""
+    if mode != "r" or offset != 0:
+        raise ValueError("Caterva2 services require mode='r' and offset=0")
+    if kwargs.get("lazy") is False:
+        raise NotImplementedError(
+            "Repository/group access requires lazy=True; select an array for lazy=False"
+        )
+    if len(roots) == 1:
+        target = blosc2.URLPath(next(iter(roots)), urlbase=urlpath.rstrip("/"), auth_token=auth_token)
+        kwargs.setdefault("lazy", True)
+        _validate_shared_cache_request(target, shared_cache, kwargs)
+        return _open_c2_urlpath(target, mode, offset, kwargs)
+    if shared_cache:
+        raise NotImplementedError("shared_cache requires a specific repository root")
+    cache_dir, cache_path = _remote_cache_options(kwargs)
+    if cache_path is not None:
+        raise ValueError("Repositories use cache_dir, not cache_path")
+    _validate_c2_urlpath_options(kwargs)
+    lazy = kwargs.pop("lazy", None)
+    if lazy is not None and not isinstance(lazy, bool):
+        raise TypeError("lazy must be a bool")
+    if kwargs.pop("assume_immutable", True) is not True:
+        raise ValueError("Repositories currently require assume_immutable=True")
+    from blosc2.remote_array import CACHE_POLICY_DEFAULT
+
+    policy, limit = blosc2.RemoteStore._validate_cache_config(
+        kwargs.pop("cache_policy", CACHE_POLICY_DEFAULT),
+        kwargs.pop("max_cache_bytes", CACHE_POLICY_DEFAULT),
+        cache_dir,
+    )
+    if kwargs:
+        raise NotImplementedError(f"{', '.join(sorted(kwargs))} is unsupported for repositories")
+    return blosc2.RemoteRepository(
+        urlpath,
+        roots,
+        auth_token=auth_token,
+        cache_dir=cache_dir,
+        cache_policy=policy,
+        max_cache_bytes=limit,
+    )
+
+
 def open(  # noqa: C901
     urlpath: str | pathlib.Path | blosc2.URLPath,
     mode: str = "r",
@@ -2787,6 +2854,7 @@ def open(  # noqa: C901
     path: str | None = None,
     shared_cache: bool = False,
     deserialize: str = "safe",
+    remote_service: str = "auto",
     **kwargs: dict,
 ) -> (
     blosc2.SChunk
@@ -2798,6 +2866,7 @@ def open(  # noqa: C901
     | blosc2.CTable
     | blosc2.RemoteCTable
     | blosc2.RemoteStore
+    | blosc2.RemoteFile
     | blosc2.LazyArray
     | blosc2.Proxy
     | blosc2.DictStore
@@ -2959,6 +3028,21 @@ def open(  # noqa: C901
             a ``.b2z`` path selects B2Z automatically. An explicit value supports
             suffix-free paths. Zarr, HDF5, B2Z and Parquet sources automatically enable
             ``lazy=True``.
+        remote_service: {"auto", "caterva2", "fsspec"}, optional
+            Select remote access independently of the source format. In auto mode,
+            HTTP(S) URLs with an @-prefixed root component are Caterva2 dataset
+            references and default to lazy access. Use ``"fsspec"`` to open an
+            ordinary remote source containing such a component without service
+            recognition. Explicit :ref:`URLPath` inputs retain their lazy defaults.
+            Ambiguous HTTP(S) base URLs are probed through ``api/roots`` with a
+            short timeout. One root opens directly; zero or multiple roots return
+            :class:`RemoteRepository`. ``"caterva2"`` requires service access and
+            disables ordinary-file fallback. Client cache budgets on a repository
+            are per root, independent of the server's shared cache.
+            Regular fixed-chunk Caterva2 SChunk leaves return :class:`RemoteFile`
+            with lazy access. ``read_bytes`` reads bounded original-byte ranges;
+            ``download`` streams the original file without exporting its Blosc
+            carrier. Irregular streams and oversized chunks are refused explicitly.
         parquet_options: dict, optional
             PyArrow ``ParquetFile`` reader options for a Parquet source. Conversion
             options such as ``columns`` and ``max_rows`` are passed separately.
@@ -3064,6 +3148,44 @@ def open(  # noqa: C901
     """
     deserialize = normalize_deserialize(deserialize)
     dataset = blosc2.core.resolve_dataset_path(dataset, path)
+    if remote_service not in {"auto", "caterva2", "fsspec"}:
+        raise ValueError("remote_service must be 'auto', 'caterva2', or 'fsspec'")
+    if isinstance(urlpath, blosc2.URLPath):
+        if remote_service == "fsspec":
+            raise ValueError("remote_service='fsspec' conflicts with URLPath")
+    else:
+        from blosc2.caterva2_url import caterva2_urlpath, discover_service, service_probe_candidate
+
+        service_path = None if remote_service == "fsspec" else caterva2_urlpath(urlpath)
+        if service_path is not None:
+            urlpath = service_path
+            kwargs.setdefault("lazy", True)
+        elif remote_service == "caterva2" or (
+            remote_service == "auto"
+            and service_probe_candidate(urlpath)
+            and dataset is None
+            and hdf5_index is None
+            and kwargs.get("source_format") is None
+            and kwargs.get("storage_options") is None
+        ):
+            if mode != "r" or offset:
+                raise ValueError("Remote service discovery requires mode='r' and offset=0")
+            if dataset is not None or hdf5_index is not None:
+                raise ValueError("dataset/path and hdf5_index are unsupported for Caterva2 services")
+            from blosc2.caterva2_url import discovery_auth_token
+
+            auth_token = discovery_auth_token(urlpath, required=remote_service == "caterva2")
+            roots = discover_service(urlpath, required=remote_service == "caterva2", auth_token=auth_token)
+            if roots is not None:
+                return _open_service_base(urlpath, roots, mode, offset, shared_cache, kwargs, auth_token)
+        elif remote_service == "fsspec" and not is_fsspec_url(urlpath):
+            raise ValueError("remote_service='fsspec' requires a remote URL")
+    if isinstance(urlpath, blosc2.URLPath):
+        if dataset is not None or hdf5_index is not None:
+            raise ValueError("dataset/path and hdf5_index are unsupported for Caterva2 sources")
+        _reject_table_buffer_options(kwargs)
+        _validate_shared_cache_request(urlpath, shared_cache, kwargs)
+        return _open_c2_urlpath(urlpath, mode, offset, kwargs)
     if kwargs.get("source_format") == "parquet" or (
         isinstance(urlpath, (str, pathlib.Path))
         and str(urlpath).split("?", 1)[0].lower().endswith(".parquet")
diff --git a/tests/b2view/test_caterva2.py b/tests/b2view/test_caterva2.py
new file mode 100644
index 000000000..9c5ba4f8d
--- /dev/null
+++ b/tests/b2view/test_caterva2.py
@@ -0,0 +1,286 @@
+"""Repository and mount-boundary browsing through the existing viewer."""
+
+import numpy as np
+import pytest
+from test_remote_caterva2 import caterva2_source  # noqa: F401
+from tui_wait import wait_until
+
+from blosc2.b2view.model import StoreBrowser
+
+
+def test_service_browser_metadata_and_previews(caterva2_source):  # noqa: F811
+    base, array, _, stats = caterva2_source
+    with StoreBrowser(base) as browser:
+        assert browser.is_tree
+        assert [node.name for node in browser.list_children()] == ["mount"]
+        assert not stats["fetches"]
+        assert [node.kind for node in browser.list_children("/mount")] == ["ndarray", "group", "ctable"]
+        assert browser.get_info("/mount").metadata["catalog_attrs"] == {"note": "curated"}
+        assert browser.get_info("/mount/table").metadata["nrows"] == 12
+        preview = browser.preview("/mount/table", start=2, stop=4, max_cols=1)
+        np.testing.assert_array_equal(preview["data"]["ident"], [2, 3])
+        assert not browser.supports_table_transforms("/mount/table")
+        for operation in (
+            lambda: browser.set_filter("/mount/table", "ident > 2"),
+            lambda: browser.set_sort("/mount/table", "ident", False),
+            lambda: browser.set_group("/mount/table", "ident", "count", None),
+            lambda: browser.read_series("/mount/table", column="ident"),
+        ):
+            with pytest.raises(NotImplementedError):
+                operation()
+        np.testing.assert_array_equal(
+            browser.preview("/mount/array", slices=(slice(2), slice(3))), array[:2, :3]
+        )
+
+
+def test_repository_browser_and_broken_sibling(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    stats["roots"]["@broken"] = {"name": "@broken"}
+    with StoreBrowser(base) as browser:
+        assert [node.name for node in browser.list_children()] == ["@broken", "@public"]
+        assert [node.name for node in browser.list_children("/@public")] == ["mount"]
+    stats["roots"].pop("@broken")
+    stats["groups"]["@public/mount"].append("broken")
+    with StoreBrowser(base) as browser:
+        children = browser.list_children("/mount")
+        assert [(node.name, node.kind) for node in children] == [
+            ("array", "ndarray"),
+            ("broken", "unavailable"),
+            ("empty", "group"),
+            ("table", "ctable"),
+        ]
+        assert next(node for node in children if node.name == "broken").has_children
+        stats["groups"]["@public/mount/broken"] = []
+        assert browser.list_children("/mount/broken") == []
+
+
+def test_published_extensions_do_not_select_direct_file_backends(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    stats["aliases"]["@public/group.h5"] = "@public/group"
+    stats["aliases"]["@public/table.parquet"] = "@public/table"
+    with StoreBrowser(base + "@public/group.h5") as browser:
+        assert browser.is_tree
+        assert [node.name for node in browser.list_children()] == ["array", "table"]
+    with StoreBrowser(base + "@public/table.parquet") as browser:
+        assert browser.kind("/") == "ctable"
+        assert browser.preview("/", stop=2)["nrows"] == 12
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+@pytest.mark.parametrize("multiple", [False, True])
+async def test_repository_tui_expands_mounts_and_previews(caterva2_source, multiple):  # noqa: F811
+    from blosc2.b2view.app import B2ViewApp
+
+    base, array, _, stats = caterva2_source
+    prefix = "/@public" if multiple else ""
+    if multiple:
+        stats["roots"]["@broken"] = {"name": "@broken"}
+    app = B2ViewApp(base, start_path=prefix + "/mount/array")
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(pilot, lambda: app.table_page is not None and bool(app.table_page["columns"]))
+        assert app.selected_path == prefix + "/mount/array"
+        page = app.table_page
+        np.testing.assert_array_equal(page["data"]["0"], array[: page["stop"], 0])
+        app.update_panels(prefix + "/mount/table")
+        await wait_until(
+            pilot, lambda: app.table_page is not None and app.table_page.get("source_kind") == "ctable"
+        )
+        assert app.table_page["nrows"] == 12
+    app.wait_for_close()
+
+
+def test_cli_service_override():
+    from blosc2.b2view.cli import build_parser
+
+    args = build_parser().parse_args(["https://host/@data/a.h5", "--remote-service", "fsspec"])
+    assert args.remote_service == "fsspec"
+
+
+@pytest.mark.parametrize(
+    ("target", "relative", "expected"),
+    [
+        ("", "/", "@public"),
+        ("", "/mount/table", "@public/mount/table"),
+        ("@public", "/mount/table", "@public/mount/table"),
+        ("@public/mount", "/array", "@public/mount/array"),
+        ("@public/table", "/", "@public/table"),
+    ],
+)
+def test_service_metadata_displays_full_path(caterva2_source, target, relative, expected):  # noqa: F811
+    from rich.console import Console
+
+    from blosc2.b2view.render import make_metadata_renderable
+
+    base, _, _, _ = caterva2_source
+    with StoreBrowser(base + target) as browser:
+        info = browser.get_info(relative)
+        assert info.path == relative
+        assert info.display_path == expected
+        console = Console(record=True, width=120)
+        console.print(make_metadata_renderable(info))
+        assert expected in console.export_text()
+        assert "/@public" not in console.export_text()
+
+
+def test_multiroot_display_does_not_duplicate_prefix(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    stats["roots"]["@broken"] = {"name": "@broken"}
+    with StoreBrowser(base) as browser:
+        info = browser.get_info("/@public/mount/table")
+        assert info.display_path == "@public/mount/table"
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_remote_table_startup_and_reload_keep_content_stable(caterva2_source, monkeypatch):  # noqa: F811
+    import threading
+
+    from textual.widgets import DataTable, Static
+
+    from blosc2.b2view.app import B2ViewApp
+
+    base, _, _, _ = caterva2_source
+    calls = []
+    entered, release = threading.Event(), threading.Event()
+    original = StoreBrowser.preview
+    block = False
+
+    def preview(browser, path, **options):
+        calls.append(options)
+        if block:
+            entered.set()
+            assert release.wait(5)
+        return original(browser, path, **options)
+
+    monkeypatch.setattr(StoreBrowser, "preview", preview)
+    app = B2ViewApp(base + "@public/mount/table")
+    assert app.theme == "blosc2"
+    try:
+        async with app.run_test(size=(120, 40)) as pilot:
+            await wait_until(pilot, lambda: app.table_page is not None and bool(app.table_page["columns"]))
+            await pilot.pause()
+            assert len(calls) == 1
+            assert not app._data_busy
+            pane = app.query_one("#data-pane")
+            assert str(pane.border_title) == "data"
+            table = app.query_one("#data-table", DataTable)
+            metadata = app.query_one("#metadata", Static)
+            page, content, count = app.table_page, metadata.content, table.row_count
+            assert page["viewport_width"] == table.size.width
+            # Repeated viewport checks while a slow fetch is pending must not
+            # clear the visible page or enqueue replacement fetches.
+            block = True
+            app.table_buffer = None
+            pending = app._load_table_page("/", 0)
+            assert pending is page
+            with monkeypatch.context() as patch:
+                patch.setattr(
+                    table, "clear", lambda **kwargs: pytest.fail("Pending reload cleared the grid")
+                )
+                app._update_data_table(pending)
+            await wait_until(pilot, entered.is_set)
+            assert app._data_busy
+            assert "loading" in str(pane.border_title)
+            frame, size = app._data_busy_frame, pane.size
+            await pilot.pause(0.25)
+            assert app._data_busy_frame > frame
+            assert pane.size == size
+            request = app._remote_page_request
+            for _ in range(3):
+                app._ensure_viewport_consistent()
+            assert app._remote_page_request == request
+            assert table.row_count == count
+            assert metadata.content == content
+            assert app.table_page is page
+            release.set()
+            await wait_until(pilot, lambda: not app._remote_page_pending)
+            assert not app._data_busy
+            assert str(pane.border_title) == "data"
+            assert len(calls) == 2
+            # Height-only resize reuses the prefetched rows, not the network.
+            await pilot.resize_terminal(120, 45)
+            await pilot.pause()
+            assert len(calls) == 2
+            assert table.row_count == count
+    finally:
+        release.set()
+        app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_remote_loading_indicator_stops_on_page_error(caterva2_source, monkeypatch):  # noqa: F811
+    from blosc2.b2view.app import B2ViewApp
+
+    base, _, _, _ = caterva2_source
+    app = B2ViewApp(base + "@public/mount/table")
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(pilot, lambda: app.table_page is not None and bool(app.table_page["columns"]))
+
+        def failed(*args, **kwargs):
+            raise OSError("Test page failure")
+
+        monkeypatch.setattr(StoreBrowser, "preview", failed)
+        app.table_buffer = None
+        app._load_table_page("/", 0)
+        assert app._data_busy
+        await wait_until(pilot, lambda: not app._remote_page_pending)
+        assert not app._data_busy
+        assert str(app.query_one("#data-pane").border_title) == "data"
+        assert app.table_page["columns"]
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_remote_table_window_is_background_and_stale_results_are_discarded(
+    caterva2_source,  # noqa: F811
+    monkeypatch,
+):
+    import threading
+
+    from blosc2.b2view.app import B2ViewApp
+
+    base, _, _, _ = caterva2_source
+    entered, release = threading.Event(), threading.Event()
+    original = StoreBrowser.prepare_row_window
+
+    def slow(self, path, start, stop):
+        entered.set()
+        assert release.wait(5)
+        return original(self, path, start, stop)
+
+    monkeypatch.setattr(StoreBrowser, "prepare_row_window", slow)
+    app = B2ViewApp(base, start_path="/mount/table")
+    try:
+        async with app.run_test(size=(120, 40)) as pilot:
+            await wait_until(
+                pilot, lambda: app.table_page is not None and app.table_page.get("source_kind") == "ctable"
+            )
+            app._enter_row_window(2, 5, backend="ctable")
+            await wait_until(pilot, entered.is_set)
+            # A slow bounded table fetch must not block event handling.
+            await pilot.press("tab")
+            app.update_panels("/mount")
+            release.set()
+            await wait_until(
+                pilot, lambda: app._selected_info is not None and app._selected_info.path == "/mount"
+            )
+            assert not app.browser.get_row_window("/mount/table")
+            app.update_panels("/mount/table")
+            await wait_until(
+                pilot, lambda: app.table_page is not None and app.table_page.get("source_kind") == "ctable"
+            )
+            app._enter_row_window(2, 5, backend="ctable")
+            await wait_until(
+                pilot,
+                lambda: app.row_window == (2, 5) and app.table_page and bool(app.table_page["columns"]),
+            )
+            assert app.table_page["nrows"] == 3
+            np.testing.assert_array_equal(app.table_page["data"]["ident"], [2, 3, 4])
+            plotted = app.browser.plot_series("/mount/table", column="ident")
+            assert plotted["n"] == 3
+    finally:
+        release.set()
+        app.wait_for_close()
diff --git a/tests/b2view/test_cli.py b/tests/b2view/test_cli.py
index 6de04a7a0..4dd315817 100644
--- a/tests/b2view/test_cli.py
+++ b/tests/b2view/test_cli.py
@@ -82,7 +82,9 @@ def run(app, **kwargs):
     for key, value in options.items():
         argv.extend(["--" + key.replace("_", "-"), value])
     assert main(argv) == 0
-    assert opened == [(url, {"storage_options": options or None, "cache_dir": None})]
+    assert opened == [
+        (url, {"storage_options": options or None, "cache_dir": None, "remote_service": "auto"})
+    ]
 
 
 def test_cache_dir_reaches_browser(monkeypatch, tmp_path):
@@ -106,7 +108,7 @@ def run(app, **kwargs):
     monkeypatch.setattr(B2ViewApp, "run", run)
     cache_path = str(tmp_path / "cache")
     assert main([url, "--cache-dir", cache_path]) == 0
-    assert opened == [(url, {"storage_options": None, "cache_dir": cache_path})]
+    assert opened == [(url, {"storage_options": None, "cache_dir": cache_path, "remote_service": "auto"})]
 
 
 def test_max_cache_bytes_reaches_browser(monkeypatch):
@@ -129,4 +131,14 @@ def run(app, **kwargs):
 
     monkeypatch.setattr(B2ViewApp, "run", run)
     assert main([url, "--max-cache-bytes", "1048576"]) == 0
-    assert opened == [(url, {"storage_options": None, "cache_dir": None, "max_cache_bytes": 1048576})]
+    assert opened == [
+        (
+            url,
+            {
+                "storage_options": None,
+                "cache_dir": None,
+                "max_cache_bytes": 1048576,
+                "remote_service": "auto",
+            },
+        )
+    ]
diff --git a/tests/b2view/test_compressed_files.py b/tests/b2view/test_compressed_files.py
new file mode 100644
index 000000000..0cc379476
--- /dev/null
+++ b/tests/b2view/test_compressed_files.py
@@ -0,0 +1,214 @@
+"""Local .b2 document carriers use bounded chunk decoding, not eager reads."""
+
+import io
+import struct
+
+import numpy as np
+import pytest
+from tui_wait import wait_until
+
+import blosc2
+from blosc2.b2view.compressed_file import CompressedFile
+from blosc2.b2view.file_preview import TEXT_BYTES
+from blosc2.b2view.model import StoreBrowser
+
+
+def write_carrier(path, payload, chunksize=4096):
+    schunk = blosc2.SChunk(
+        urlpath=str(path), mode="w", chunksize=chunksize, cparams={"typesize": 1}, contiguous=True
+    )
+    for start in range(0, len(payload), chunksize):
+        schunk.append_data(payload[start : start + chunksize])
+
+
+@pytest.mark.parametrize("file_url", [False, True])
+def test_text_carrier_preview_is_bounded(tmp_path, monkeypatch, file_url):
+    path = tmp_path / "README.md.b2"
+    payload = b"a" * (TEXT_BYTES * 4)
+    write_carrier(path, payload)
+    calls = []
+    original = CompressedFile._chunk
+
+    def chunk(file, index):
+        calls.append(index)
+        return original(file, index)
+
+    monkeypatch.setattr(CompressedFile, "_chunk", chunk)
+    source = path.as_uri() if file_url else str(path)
+    with StoreBrowser(source) as browser:
+        info = browser.get_info("/")
+        assert info.kind == "file"
+        assert info.metadata["name"] == "README.md"
+        assert info.metadata["carrier"] == "README.md.b2"
+        assert not calls
+        preview = browser.preview("/")
+        assert len(preview["file_text"]) == TEXT_BYTES
+        assert "truncated" in preview["notice"]
+        assert calls == list(range(TEXT_BYTES // 4096))
+
+
+def test_streamed_download_and_alias_lifetime(tmp_path, monkeypatch):
+    path = tmp_path / "notes.txt.b2"
+    payload = b"hello world\n" * 100_000
+    write_carrier(path, payload, chunksize=1 << 20)
+    file = CompressedFile(path)
+    alias = file.alias()
+    file.close()
+    calls = []
+    original = alias._chunk
+
+    def chunk(index):
+        calls.append(index)
+        return original(index)
+
+    monkeypatch.setattr(alias, "_chunk", chunk)
+    destination = tmp_path / "notes.txt"
+    progress = []
+    alias.download(destination, progress=lambda done, total: progress.append((done, total)))
+    assert destination.read_bytes() == payload
+    assert calls == list(range(alias.nchunks))
+    assert progress[-1] == (len(payload), len(payload))
+    with pytest.raises(FileExistsError):
+        alias.download(destination)
+    with pytest.raises(InterruptedError):
+        alias.download(tmp_path / "cancelled.txt", cancel=lambda: True)
+    assert not (tmp_path / "cancelled.txt").exists()
+    assert not list(tmp_path.glob(".b2view-download-*"))
+    alias.close()
+
+
+def test_oversized_chunk_rejected_before_decompression(tmp_path, monkeypatch):
+    path = tmp_path / "large.txt.b2"
+    payload = b"small"
+    write_carrier(path, payload, chunksize=len(payload))
+    with StoreBrowser(str(path)) as browser:
+
+        def forbidden(*args, **kwargs):
+            pytest.fail("Oversized chunk was fetched/decompressed")
+
+        monkeypatch.setattr(blosc2.SChunk, "get_chunk", forbidden)
+        header = bytearray(browser.store._schunk.get_lazychunk(0))
+        struct.pack_into("<I", header, 4, (256 << 20) + 1)
+        monkeypatch.setattr(blosc2.SChunk, "get_lazychunk", lambda *args: header)
+        preview = browser.preview("/")
+        assert preview["preview_status"] == "Preview failed"
+        assert "256 MiB" in str(preview["preview_error"])
+        with pytest.raises(ValueError, match="256 MiB"):
+            browser.store.download(tmp_path / "large.txt")
+    assert not (tmp_path / "large.txt").exists()
+    assert not list(tmp_path.glob(".b2view-download-*"))
+
+
+def test_compressed_size_limit_before_payload_copy(tmp_path, monkeypatch):
+    path = tmp_path / "random.txt.b2"
+    payload = b"small"
+    write_carrier(path, payload, chunksize=len(payload))
+    file = CompressedFile(path)
+
+    def forbidden(*args, **kwargs):
+        pytest.fail("Oversized compressed chunk was copied")
+
+    monkeypatch.setattr(blosc2.SChunk, "get_chunk", forbidden)
+    header = bytearray(file._schunk.get_lazychunk(0))
+    struct.pack_into("<I", header, 12, (32 << 20) + 1)
+    monkeypatch.setattr(blosc2.SChunk, "get_lazychunk", lambda *args: header)
+    with pytest.raises(ValueError, match="32 MiB compressed"):
+        file.read_bytes(0, 1)
+    file.close()
+
+
+@pytest.mark.parametrize("compressed", [False, True])
+def test_chunks_above_previous_limits_are_readable(tmp_path, compressed):
+    path = tmp_path / "large.txt.b2"
+    payload = (
+        np.random.default_rng(42).integers(0, 256, size=9 << 20, dtype=np.uint8).tobytes()
+        if compressed
+        else b"a" * (17 << 20)
+    )
+    write_carrier(path, payload, chunksize=len(payload))
+    file = CompressedFile(path)
+    try:
+        assert file.read_bytes(0, 64) == payload[:64]
+    finally:
+        file.close()
+
+
+def test_nonzero_byte_ranges_and_closed_handle(tmp_path):
+    path = tmp_path / "note.txt.b2"
+    payload = b"abcdefghijklmnopqrstuvwxyz" * 1000
+    write_carrier(path, payload, chunksize=1024)
+    file = CompressedFile(path)
+    assert file.read_bytes(1000, 2100) == payload[1000:2100]
+    assert file.read_bytes(len(payload), len(payload)) == b""
+    file.close()
+    with pytest.raises(RuntimeError, match="closed"):
+        file.read_bytes(0, 1)
+
+
+def test_structural_metadata_is_not_treated_as_document_bytes(tmp_path):
+    path = tmp_path / "object.txt.b2"
+    schunk = blosc2.SChunk(
+        urlpath=str(path), mode="w", contiguous=True, chunksize=8, meta={"b2o": {"kind": "object"}}
+    )
+    schunk.append_data(b"payload")
+    del schunk
+    with pytest.raises(ValueError, match="serialized object"):
+        CompressedFile(path)
+
+
+def test_pdf_image_empty_and_native_classification(tmp_path):
+    pdf = tmp_path / "doc.pdf.b2"
+    write_carrier(pdf, b"%PDF-1.4\nExample")
+    with StoreBrowser(str(pdf)) as browser:
+        assert browser.preview("/")["preview_status"] == "Preview unavailable"
+    pil = pytest.importorskip("PIL.Image")
+    stream = io.BytesIO()
+    pil.new("RGB", (20, 10), "red").save(stream, format="PNG")
+    image = tmp_path / "image.png.b2"
+    write_carrier(image, stream.getvalue())
+    with StoreBrowser(str(image)) as browser:
+        assert browser.preview("/")["file_image"].size == (20, 10)
+    empty = tmp_path / "empty.txt.b2"
+    write_carrier(empty, b"")
+    with StoreBrowser(str(empty)) as browser:
+        assert browser.preview("/")["file_text"] == ""
+    plain = tmp_path / "data.b2"
+    write_carrier(plain, b"plain native data")
+    with StoreBrowser(str(plain)) as browser:
+        assert browser.kind("/") == "schunk"
+    masquerade = tmp_path / "array.md.b2"
+    blosc2.asarray(np.arange(4), urlpath=str(masquerade))
+    with pytest.raises(ValueError, match="SChunk"):
+        StoreBrowser(str(masquerade))
+    with StoreBrowser(str(tmp_path)) as browser:
+        kinds = {node.name: node.kind for node in browser.list_children()}
+        assert kinds["doc.pdf.b2"] == "file"
+        assert kinds["data.b2"] == "schunk"
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_carrier_tui_download_uses_original_name(tmp_path):
+    from textual.widgets import Input, Static
+
+    from blosc2.b2view.app import B2ViewApp, FileTransferScreen
+
+    carrier = tmp_path / "README.md.b2"
+    payload = b"# Hello\n\nFrom a compressed carrier."
+    write_carrier(carrier, payload)
+    app = B2ViewApp(str(tmp_path), start_path="/README.md.b2")
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(pilot, lambda: app._selected_info is not None and app._selected_info.kind == "file")
+        assert app._selected_info.metadata["name"] == "README.md"
+        app.action_download_file()
+        await wait_until(pilot, lambda: isinstance(app.screen, FileTransferScreen))
+        assert app.screen.query_one(Input).value.endswith("README.md")
+        destination = tmp_path / "README.md"
+        app.screen.query_one(Input).value = str(destination)
+        await pilot.press("enter")
+        await wait_until(
+            pilot, lambda: "Saved" in str(app.screen.query_one("#file-status", Static).render())
+        )
+        assert destination.read_bytes() == payload
+        await pilot.press("escape")
+    app.wait_for_close()
diff --git a/tests/b2view/test_directories.py b/tests/b2view/test_directories.py
new file mode 100644
index 000000000..f7f18e793
--- /dev/null
+++ b/tests/b2view/test_directories.py
@@ -0,0 +1,154 @@
+"""Lazy ordinary directories, including expandable native dataset mounts."""
+
+import numpy as np
+import pytest
+from tui_wait import wait_until
+
+import blosc2
+from blosc2.b2view.model import StoreBrowser
+
+
+@pytest.mark.parametrize("backend", ["local", "file", "memory"])
+def test_directory_browsing_is_lazy(tmp_path, backend):
+    root = tmp_path / "root"
+    root.mkdir()
+    (root / "sub").mkdir()
+    (root / "sub/README.md").write_text("# Hello")
+    (root / "broken.b2nd").write_bytes(b"broken")
+    if backend == "memory":
+        fs = pytest.importorskip("fsspec").filesystem("memory")
+        source = "memory://b2view-directory/root"
+        fs.pipe(source + "/sub/README.md", b"# Hello")
+        fs.pipe(source + "/broken.b2nd", b"broken")
+    else:
+        source = root.as_uri() if backend == "file" else str(root) + "/"
+    with StoreBrowser(source, cache_dir=str(tmp_path / "cache")) as browser:
+        assert browser.is_tree
+        children = browser.list_children()
+        assert [node.name for node in children] == ["broken.b2nd", "sub"]
+        assert not browser.store._browsers
+        assert browser.get_info("/").kind == "group"
+        assert browser.list_children("/sub")[0].kind == "file"
+        assert not browser.store._browsers
+        assert browser.preview("/sub/README.md")["file_text"] == "# Hello"
+        with pytest.raises((RuntimeError, ValueError)):
+            browser.get_info("/broken.b2nd")
+        assert browser.preview("/sub/README.md")["markdown"]
+
+
+@pytest.mark.parametrize("backend", ["local", "memory"])
+def test_dataset_mounts_and_standalone_arrays(tmp_path, backend):
+    data = np.arange(10)
+    blosc2.asarray(data, urlpath=str(tmp_path / "array.b2nd"))
+    with blosc2.TreeStore(str(tmp_path / "tree.b2z"), mode="w") as tree:
+        tree["/group/array"] = blosc2.asarray(data)
+    source = str(tmp_path)
+    if backend == "memory":
+        fs = pytest.importorskip("fsspec").filesystem("memory")
+        source = "memory://b2view-directory/datasets"
+        for name in ("array.b2nd", "tree.b2z"):
+            fs.pipe(source + "/" + name, (tmp_path / name).read_bytes())
+    with StoreBrowser(source, cache_dir=str(tmp_path / "cache")) as browser:
+        nodes = {node.name: node for node in browser.list_children()}
+        assert nodes["tree.b2z"].has_children
+        assert not nodes["array.b2nd"].has_children
+        assert not browser.store._browsers
+        assert browser.get_info("/array.b2nd").kind == "ndarray"
+        assert browser.list_children("/tree.b2z")[0].path == "/tree.b2z/group"
+        assert browser.list_children("/tree.b2z/group")[0].path == "/tree.b2z/group/array"
+        np.testing.assert_array_equal(browser.preview("/tree.b2z/group/array")["data"]["value"], data)
+    with StoreBrowser(str(tmp_path / "tree.b2z")) as browser:
+        assert browser.is_tree
+        assert browser.list_children()[0].name == "group"
+
+
+def test_hdf5_mount_in_directory(tmp_path):
+    h5py = pytest.importorskip("h5py")
+    data = np.arange(6)
+    with h5py.File(tmp_path / "data.h5", "w") as file:
+        file.create_dataset("group/array", data=data)
+    with StoreBrowser(str(tmp_path)) as browser:
+        assert browser.list_children()[0].has_children
+        assert browser.list_children("/data.h5")[0].path == "/data.h5/group"
+        np.testing.assert_array_equal(browser.preview("/data.h5/group/array")["data"]["value"], data)
+
+
+def test_chained_fsspec_directory(tmp_path):
+    pytest.importorskip("fsspec")
+    import zipfile
+
+    archive = tmp_path / "files.zip"
+    with zipfile.ZipFile(archive, "w") as file:
+        file.writestr("notes/README.md", "# Hello")
+    with StoreBrowser(f"zip://notes::{archive.as_uri()}") as browser:
+        assert browser.is_tree
+        assert browser.list_children()[0].name == "README.md"
+        assert browser.preview("/README.md")["file_text"] == "# Hello"
+
+
+def test_symlinks_and_parent_paths_do_not_escape_root(tmp_path):
+    root = tmp_path / "root"
+    root.mkdir()
+    outside = tmp_path / "outside.txt"
+    outside.write_text("private")
+    try:
+        (root / "link.txt").symlink_to(outside)
+    except OSError:
+        pytest.skip("Symlinks unavailable")
+    with StoreBrowser(str(root)) as browser:
+        assert browser.list_children()[0].kind == "unsupported"
+        with pytest.raises(ValueError, match="symlinks"):
+            browser.get_info("/link.txt")
+        with pytest.raises(ValueError, match="escape"):
+            browser.get_info("/../outside.txt")
+
+
+@pytest.mark.parametrize("operation", ["get_info", "list_children", "__getitem__"])
+def test_double_slash_paths_do_not_escape_root(tmp_path, operation):
+    from blosc2.b2view.directory import DirectoryStore
+
+    root = tmp_path / "root"
+    root.mkdir()
+    outside = tmp_path / "outside.txt"
+    outside.write_text("private")
+    with pytest.raises(ValueError, match="escape"):
+        getattr(DirectoryStore(str(root)), operation)("//" + outside.as_posix().lstrip("/"))
+
+
+def test_windows_drive_join_does_not_escape_root():
+    from pathlib import PureWindowsPath
+
+    from blosc2.b2view.directory import DirectoryStore
+
+    store = object.__new__(DirectoryStore)
+    store.fs = None
+    store.root = PureWindowsPath("C:/selected")
+    # A rejection must happen before attempting filesystem inspection.
+    with pytest.raises(ValueError, match="escape"):
+        store._resolve("/D:/private.txt")
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_directory_tui_navigation_and_refresh(tmp_path):
+    from textual.widgets import Static
+
+    from blosc2.b2view.app import B2ViewApp
+
+    (tmp_path / "README.md").write_text("# Hello")
+    app = B2ViewApp(str(tmp_path))
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(pilot, lambda: app._selected_info is not None)
+        assert app.browser.is_tree
+        assert app.query_one("#tree-pane").display
+        app.update_panels("/README.md")
+        await wait_until(
+            pilot, lambda: "T: raw/Markdown" in str(app.query_one("#data-header", Static).render())
+        )
+        await pilot.press("T")
+        await wait_until(pilot, lambda: "# Hello" in str(app.query_one("#preview", Static).render()))
+        (tmp_path / "new.txt").write_text("new")
+        app.action_refresh()
+        await wait_until(pilot, lambda: app.browser is not None and app._selected_info is not None)
+        assert "new.txt" in [node.name for node in app.browser.list_children()]
+    app.wait_for_close()
diff --git a/tests/b2view/test_files.py b/tests/b2view/test_files.py
new file mode 100644
index 000000000..f1e1b7d40
--- /dev/null
+++ b/tests/b2view/test_files.py
@@ -0,0 +1,348 @@
+"""Ordinary-file preview and explicit download/external-open UI tests."""
+
+import io
+
+import pytest
+from test_remote_caterva2 import caterva2_source  # noqa: F401
+from test_remote_file import file_source  # noqa: F401
+from tui_wait import wait_until
+
+from blosc2.b2view.file_preview import IMAGE_PIXELS, TEXT_BYTES, open_external, preview_file, safe_text
+from blosc2.b2view.model import StoreBrowser
+
+
+class BytesFile:
+    def __init__(self, name, data):
+        self.name, self.data = name, data
+        self.nbytes = len(data)
+        self.reads = []
+
+    def read_bytes(self, start, stop):
+        self.reads.append((start, stop))
+        return self.data[start:stop]
+
+
+def test_text_limits_controls_and_binary_fallback():
+    file = BytesFile("README.md", b"a" * (TEXT_BYTES - 1) + "é".encode() + b"long content")
+    result = preview_file(file)
+    assert result["markdown"]
+    assert "truncated" in result["notice"]
+    assert "\ufffd" not in result["file_text"]
+    assert file.reads == [(0, TEXT_BYTES)]
+    assert safe_text("hello\x1b[31mred\x1b[0m\x1b]8;;https://evil\x07link\x1b]8;;\x07\0") == "helloredlink"
+    assert "Binary" in preview_file(BytesFile("bad.md", b"a\0b"))["message"]
+    assert "Invalid UTF-8" in preview_file(BytesFile("bad.txt", b"a\xffb"))["notice"]
+    assert "truncated" in preview_file(BytesFile("many.txt", b"x\n" * 1001))["notice"]
+    assert not preview_file(BytesFile("README.md", b"# Title"), raw=True)["markdown"]
+
+
+def test_pdf_and_binary_do_not_fetch():
+    for name in ("doc.pdf", "unknown.bin"):
+        file = BytesFile(name, b"unknown payload")
+        result = preview_file(file)
+        assert result["preview_status"] == "Preview unavailable"
+        assert "download" in result["actions"]
+        assert file.reads == []
+
+
+def test_missing_image_dependency_does_not_read(monkeypatch):
+    monkeypatch.setitem(__import__("sys").modules, "PIL", None)
+    file = BytesFile("image.png", b"not needed")
+    assert "needs Pillow" in preview_file(file)["message"]
+    assert preview_file(file)["preview_status"] == "Missing dependency"
+    assert file.reads == []
+
+
+@pytest.mark.parametrize(
+    ("name", "external", "toggle"),
+    [
+        ("README.md", True, True),
+        ("note.txt", True, False),
+        ("data.json", False, False),
+        ("run.py", False, False),
+        ("doc.pdf", True, False),
+        ("image.png", True, False),
+        ("unknown.bin", False, False),
+    ],
+)
+def test_file_action_hints_match_capabilities(name, external, toggle):
+    from blosc2.b2view.file_preview import file_actions, file_fallback
+    from blosc2.b2view.render import make_preview_renderables
+
+    hints = file_actions(name, markdown=True)
+    assert "D: download" in hints
+    assert ("O:" in hints) == external
+    assert ("T:" in hints) == toggle
+    fallback = file_fallback(name, "Preview unavailable", "No inline preview.")
+    header, body = make_preview_renderables(fallback)
+    assert header.plain == "Preview unavailable"
+    assert body.plain == "No inline preview.\n\n" + file_actions(name)
+    assert "T:" not in fallback["actions"]
+
+
+def test_read_failure_is_not_an_unsupported_preview():
+    class BrokenFile(BytesFile):
+        def read_bytes(self, start, stop):
+            raise OSError("https://host/path?token=secret")
+
+    result = preview_file(BrokenFile("note.txt", b"hello"))
+    assert result["preview_status"] == "Preview failed"
+    assert "secret" not in result["message"]
+    assert isinstance(result["preview_error"], OSError)
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_read_failure_preserves_metadata_and_has_safe_fallback(file_source, monkeypatch):  # noqa: F811
+    from textual.widgets import Static
+
+    import blosc2
+    from blosc2.b2view.app import B2ViewApp
+
+    def fail(*args, **kwargs):
+        raise OSError("Cannot read https://host/file?token=secret\x1b[31m")
+
+    monkeypatch.setattr(blosc2.RemoteFile, "read_bytes", fail)
+    base, _, _ = file_source
+    app = B2ViewApp(base, start_path="/README.md")
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(
+            pilot, lambda: "Preview failed" in str(app.query_one("#data-header", Static).render())
+        )
+        body = str(app.query_one("#preview", Static).render())
+        assert "OSError" in body
+        assert "secret" not in body
+        assert "\x1b" not in body
+        assert "D: download" in body
+        assert "O: open externally" in body
+        assert "T:" not in body
+        assert app._selected_info.kind == "file"
+        from rich.console import Console
+
+        console = Console(file=io.StringIO(), width=120)
+        console.print(app.query_one("#metadata", Static).content)
+        assert "README.md" in console.file.getvalue()
+        assert app.return_code is None
+    app.wait_for_close()
+
+
+def test_image_preview_and_limits(monkeypatch):
+    pil = pytest.importorskip("PIL.Image")
+    stream = io.BytesIO()
+    pil.new("RGB", (20, 10), "blue").save(stream, format="PNG")
+    result = preview_file(BytesFile("image.png", stream.getvalue()))
+    assert result["file_image"].size == (20, 10)
+    assert "20 × 10" in result["message"]
+    assert "Invalid" in preview_file(BytesFile("image.jpg", b"not a JPEG"))["message"]
+    monkeypatch.setattr("blosc2.b2view.file_preview.IMAGE_PIXELS", 10)
+    assert "budget" in preview_file(BytesFile("image.png", stream.getvalue()))["message"]
+    assert IMAGE_PIXELS <= (64 << 20) // 4
+
+
+def test_external_open_is_shell_free_and_restricted(tmp_path, monkeypatch):
+    import sys
+
+    document = tmp_path / "--unsafe name.pdf"
+    document.write_bytes(b"%PDF-1.4\n")
+    seen = []
+    monkeypatch.setattr("shutil.which", lambda name: "/usr/bin/" + name)
+    monkeypatch.setattr("subprocess.run", lambda args, **kw: seen.append((args, kw)))
+    if sys.platform == "win32":
+        pytest.skip("POSIX launcher contract")
+    open_external(document)
+    assert seen[0][0][1] == str(document.absolute())
+    assert "shell" not in seen[0][1]
+    script = tmp_path / "run.py"
+    script.write_text("print('danger')")
+    with pytest.raises(ValueError, match="restricted"):
+        open_external(script)
+    document.write_bytes(b"not pdf")
+    with pytest.raises(ValueError, match="content"):
+        open_external(document)
+
+
+def test_browser_file_metadata_and_preview(file_source):  # noqa: F811
+    base, _, stats = file_source
+    with StoreBrowser(base) as browser:
+        assert browser.kind("/README.md") == "file"
+        info = browser.get_info("/README.md")
+        assert info.display_path == "@public/README.md"
+        assert info.metadata["name"] == "README.md"
+        assert not stats["file_chunks"]
+        assert browser.preview("/README.md")["markdown"]
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_tui_file_preview_and_download(file_source, tmp_path):  # noqa: F811
+    from textual.widgets import Input, Static
+
+    from blosc2.b2view.app import B2ViewApp, FileTransferScreen
+
+    base, payload, _ = file_source
+    app = B2ViewApp(base, start_path="/README.md")
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(pilot, lambda: app._selected_info is not None and app._selected_info.kind == "file")
+        assert app._selected_info.display_path == "@public/README.md"
+        await pilot.press("T")
+        assert app._file_raw
+        await wait_until(pilot, lambda: not app._remote_page_pending)
+        app.action_download_file()
+        await wait_until(pilot, lambda: isinstance(app.screen, FileTransferScreen))
+        destination = tmp_path / "README.md"
+        app.screen.query_one(Input).value = str(destination)
+        await pilot.press("enter")
+        await wait_until(pilot, destination.exists)
+        assert destination.read_bytes() == payload
+        await wait_until(
+            pilot, lambda: "Saved" in str(app.screen.query_one("#file-status", Static).render())
+        )
+        await pilot.press("escape")
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_pdf_external_open_requires_only_explicit_action(file_source, tmp_path, monkeypatch):  # noqa: F811
+    from textual.widgets import Input
+
+    import blosc2
+    from blosc2.b2view.app import B2ViewApp, FileTransferScreen
+
+    base, _, stats = file_source
+    data = b"%PDF-1.4\nDocument fixture"
+    stream = blosc2.SChunk(chunksize=64, cparams={"typesize": 1})
+    stream.append_data(data)
+    stats["files"]["@public/doc.pdf"] = stream
+    stats["groups"]["@public"].append("doc.pdf")
+    launched = []
+    monkeypatch.setattr("blosc2.b2view.file_preview.open_external", launched.append)
+    app = B2ViewApp(base, start_path="/doc.pdf")
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(pilot, lambda: app._selected_info is not None and app._selected_info.kind == "file")
+        assert not stats["file_chunks"]
+        app.action_open_file()
+        await wait_until(pilot, lambda: isinstance(app.screen, FileTransferScreen))
+        destination = tmp_path / "doc.pdf"
+        app.screen.query_one(Input).value = str(destination)
+        assert not app.screen.query("#file-consent")
+        assert not destination.exists()
+        assert not launched
+        await pilot.press("enter")
+        await wait_until(pilot, lambda: bool(launched))
+        assert destination.read_bytes() == data
+        await pilot.press("escape")
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+@pytest.mark.parametrize("image_widget", [True, False, "real", "broken"])
+async def test_image_widget_and_dependency_fallback(file_source, monkeypatch, image_widget):  # noqa: F811
+    from textual.widgets import Static
+
+    import blosc2
+    from blosc2.b2view.app import B2ViewApp
+
+    pil = pytest.importorskip("PIL.Image")
+    base, _, stats = file_source
+    encoded = io.BytesIO()
+    pil.new("RGB", (20, 10), "red").save(encoded, format="PNG")
+    stream = blosc2.SChunk(chunksize=1024, cparams={"typesize": 1})
+    stream.append_data(encoded.getvalue())
+    stats["files"]["@public/image.png"] = stream
+    stats["groups"]["@public"].append("image.png")
+    if image_widget == "real":
+        pytest.importorskip("textual_image.widget")
+    elif image_widget == "broken":
+
+        def broken_widget(image):
+            raise RuntimeError("Cannot display https://host/image?token=secret")
+
+        monkeypatch.setattr("blosc2.b2view.app.TextualImage", broken_widget)
+    else:
+        monkeypatch.setattr(
+            "blosc2.b2view.app.TextualImage",
+            (lambda image: Static(f"Image {image.size}")) if image_widget else None,
+        )
+    app = B2ViewApp(base, start_path="/image.png")
+    async with app.run_test(size=(120, 40)) as pilot:
+        if image_widget == "broken":
+            await wait_until(
+                pilot, lambda: "Preview failed" in str(app.query_one("#data-header", Static).render())
+            )
+            body = str(app.query_one("#preview", Static).render())
+            assert "RuntimeError" in body
+            assert "secret" not in body
+            assert "D: download" in body
+            assert "O: open externally" in body
+        elif image_widget:
+            await wait_until(pilot, lambda: bool(app.query_one("#file-image").children))
+            await wait_until(pilot, lambda: app.query_one("#file-image").children[0].region.height > 0)
+            image = app.query_one("#file-image").children[0]
+            assert image.region.overlaps(app.query_one("#data-scroll").region)
+            await pilot.resize_terminal(80, 30)
+            await wait_until(pilot, lambda: image.region.height > 0)
+            assert image.region.overlaps(app.query_one("#data-scroll").region)
+        else:
+            await wait_until(
+                pilot, lambda: "needs textual-image" in str(app.query_one("#preview", Static).render())
+            )
+            assert "Missing dependency" in str(app.query_one("#data-header", Static).render())
+            assert "D: download" in str(app.query_one("#preview", Static).render())
+            assert "O: open externally" in str(app.query_one("#preview", Static).render())
+        app.update_panels("/mount")
+        await wait_until(
+            pilot, lambda: app._selected_info is not None and app._selected_info.kind == "group"
+        )
+        await wait_until(pilot, lambda: not app.query_one("#file-image").children)
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_slow_transfer_can_cancel_without_blocking_ui(file_source, tmp_path, monkeypatch):  # noqa: F811
+    import threading
+
+    from textual.widgets import Input
+
+    import blosc2
+    from blosc2.b2view.app import B2ViewApp, FileTransferScreen
+
+    entered, release, finished = threading.Event(), threading.Event(), threading.Event()
+    original = blosc2.RemoteFile._chunk
+
+    def slow(file, index, cancel=None):
+        if cancel is not None:
+            entered.set()
+            assert release.wait(5)
+        try:
+            return original(file, index, cancel)
+        finally:
+            if cancel is not None:
+                finished.set()
+
+    monkeypatch.setattr(blosc2.RemoteFile, "_chunk", slow)
+    base, _, _ = file_source
+    app = B2ViewApp(base, start_path="/README.md")
+    destination = tmp_path / "cancelled.md"
+    try:
+        async with app.run_test(size=(120, 40)) as pilot:
+            await wait_until(
+                pilot, lambda: app._selected_info is not None and app._selected_info.kind == "file"
+            )
+            app.action_download_file()
+            await wait_until(pilot, lambda: isinstance(app.screen, FileTransferScreen))
+            app.screen.query_one(Input).value = str(destination)
+            await pilot.press("enter")
+            await wait_until(pilot, entered.is_set)
+            await pilot.press("escape")
+            assert not isinstance(app.screen, FileTransferScreen)
+            await pilot.press("tab")
+            release.set()
+            await wait_until(pilot, finished.is_set)
+            await wait_until(pilot, lambda: not list(tmp_path.glob(".b2view-download-*")))
+            assert not destination.exists()
+    finally:
+        release.set()
+        app.wait_for_close()
diff --git a/tests/b2view/test_notebooks.py b/tests/b2view/test_notebooks.py
new file mode 100644
index 000000000..f228bdc0d
--- /dev/null
+++ b/tests/b2view/test_notebooks.py
@@ -0,0 +1,339 @@
+"""Passive notebook previews share file transports without executing kernels."""
+
+import base64
+import io
+import json
+
+import pytest
+from test_remote_caterva2 import caterva2_source  # noqa: F401
+from test_remote_file import file_source  # noqa: F401
+from tui_wait import wait_until
+
+import blosc2
+from blosc2.b2view.file_preview import TEXT_BYTES, TEXT_LINES, preview_file
+from blosc2.b2view.model import StoreBrowser
+from blosc2.b2view.notebook_preview import NOTEBOOK_BYTES, NOTEBOOK_CELLS
+from blosc2.b2view.render import make_preview_renderables
+
+
+class NotebookFile:
+    name = "example.ipynb"
+
+    def __init__(self, notebook):
+        self.data = json.dumps(notebook).encode()
+        self.nbytes = len(self.data)
+        self.reads = []
+
+    def read_bytes(self, start, stop):
+        self.reads.append((start, stop))
+        return self.data[start:stop]
+
+
+def notebook(cells):
+    return {
+        "nbformat": 4,
+        "nbformat_minor": 5,
+        "metadata": {"language_info": {"name": "python"}},
+        "cells": cells,
+    }
+
+
+def sample_notebook():
+    return notebook(
+        [
+            {"cell_type": "markdown", "source": ["# Title\n", "Some **Markdown**."], "metadata": {}},
+            {
+                "cell_type": "code",
+                "source": "raise RuntimeError('never execute')",
+                "metadata": {},
+                "outputs": [
+                    {"output_type": "stream", "text": "hello\x1b[31m red\x1b[0m\n"},
+                    {
+                        "output_type": "display_data",
+                        "data": {"text/plain": "result", "text/html": "<script>evil()</script>"},
+                    },
+                ],
+            },
+            {"cell_type": "raw", "source": "plain raw cell", "metadata": {}},
+        ]
+    )
+
+
+def saved_plot(mime="image/png", size=(20, 10)):
+    pil = pytest.importorskip("PIL.Image")
+    stream = io.BytesIO()
+    pil.new("RGB", size, "red").save(stream, format="PNG" if mime == "image/png" else "JPEG")
+    return base64.b64encode(stream.getvalue()).decode("ascii")
+
+
+def plot_notebook(data):
+    return notebook(
+        [
+            {
+                "cell_type": "code",
+                "source": "# saved plot, never executed",
+                "outputs": [
+                    {"output_type": "display_data", "data": data},
+                ],
+            }
+        ]
+    )
+
+
+@pytest.mark.parametrize("mime", ["image/png", "image/jpeg"])
+def test_saved_notebook_images_are_passive(mime):
+    encoded = saved_plot(mime)
+    preview = preview_file(
+        NotebookFile(
+            plot_notebook({mime: [encoded[:20] + "\n", encoded[20:]], "text/plain": "Saved figure"})
+        )
+    )
+    cell = preview["notebook_cells"][0]
+    assert cell["images"][0].size == (20, 10)
+    assert cell["output"] == "Saved figure"
+    assert not preview["notice"]
+
+
+def test_notebook_images_share_count_pixel_and_byte_limits(monkeypatch):
+    from blosc2.b2view import notebook_preview
+
+    encoded = saved_plot()
+    cells = plot_notebook({"image/png": encoded})["cells"] * (notebook_preview.NOTEBOOK_IMAGES + 1)
+    preview = preview_file(NotebookFile(notebook(cells)))
+    assert sum(len(cell["images"]) for cell in preview["notebook_cells"]) == notebook_preview.NOTEBOOK_IMAGES
+    assert "budget" in preview["notice"]
+    monkeypatch.setattr(notebook_preview, "IMAGE_PIXELS", 300)
+    preview = preview_file(NotebookFile(notebook(cells[:2])))
+    assert [len(cell["images"]) for cell in preview["notebook_cells"]] == [1, 0]
+    assert "pixel budget" in preview["notice"]
+    monkeypatch.setattr(notebook_preview, "IMAGE_BYTES", 1)
+    monkeypatch.setattr(
+        notebook_preview,
+        "preview_image_bytes",
+        lambda *args, **kwargs: pytest.fail("Over-budget image reached decoder"),
+    )
+    preview = preview_file(NotebookFile(plot_notebook({"image/png": encoded})))
+    assert not preview["notebook_cells"][0]["images"]
+    assert "byte budget" in preview["notice"]
+
+
+@pytest.mark.parametrize("value", ["not base64!", "", 42, base64.b64encode(b"not an image").decode()])
+def test_invalid_saved_image_keeps_notebook_text(value):
+    preview = preview_file(NotebookFile(plot_notebook({"image/png": value, "text/plain": "still readable"})))
+    assert preview["notebook_cells"][0]["output"] == "still readable"
+    assert not preview["notebook_cells"][0]["images"]
+    assert "omitted" in preview["notice"]
+
+
+def test_notebook_image_decoder_failure_preserves_cells(monkeypatch):
+    monkeypatch.setattr(
+        "blosc2.b2view.notebook_preview.preview_image_bytes",
+        lambda *args, **kwargs: {"message": "Image preview needs Pillow."},
+    )
+    preview = preview_file(NotebookFile(plot_notebook({"image/png": saved_plot()})))
+    assert not preview["notebook_cells"][0]["images"]
+    assert "Pillow" in preview["notice"]
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+@pytest.mark.parametrize("widget", ["real", "missing", "broken"])
+async def test_notebook_saved_plots_inline_and_raw_toggle(tmp_path, monkeypatch, widget):
+    from textual.widgets import Static
+
+    from blosc2.b2view.app import B2ViewApp
+
+    if widget == "real":
+        pytest.importorskip("textual_image.widget")
+    elif widget == "missing":
+        monkeypatch.setattr("blosc2.b2view.app.TextualImage", None)
+    else:
+
+        def broken(*args):
+            raise RuntimeError("secret must not appear")
+
+        monkeypatch.setattr("blosc2.b2view.app.TextualImage", broken)
+    path = tmp_path / "plots.ipynb"
+    path.write_text(json.dumps(plot_notebook({"image/png": saved_plot()})))
+    app = B2ViewApp(str(path))
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(pilot, lambda: bool(app.query_one("#file-image").children))
+        container = app.query_one("#file-image")
+        if widget == "real":
+            assert len(container.children) == 2
+            await wait_until(pilot, lambda: container.children[1].region.height > 0)
+            assert "Cell 1" in container.children[0].content.title.plain
+            assert app.query_one("#preview", Static).content == ""
+        elif widget == "missing":
+            assert "textual-image" in str(container.children[0].render())
+            from rich.console import Console
+
+            console = Console()
+            with console.capture() as capture:
+                console.print(app.query_one("#preview", Static).content)
+            assert "Cell 1" in capture.get()
+        else:
+            assert "could not be displayed" in str(container.children[1].render())
+            assert "secret" not in str(container.children[1].render())
+        await pilot.press("T")
+        await wait_until(pilot, lambda: not container.children)
+        assert "nbformat" in str(app.query_one("#preview", Static).render())
+        await pilot.press("T")
+        await wait_until(pilot, lambda: bool(container.children))
+    app.wait_for_close()
+
+
+def test_cells_and_outputs_are_passive_and_safe():
+    file = NotebookFile(sample_notebook())
+    preview = preview_file(file)
+    assert preview["language"] == "python"
+    cells = preview["notebook_cells"]
+    assert [cell["kind"] for cell in cells] == ["markdown", "code", "raw"]
+    assert "never execute" in cells[1]["source"]
+    assert "hello red" in cells[1]["output"]
+    assert "script" not in cells[1]["output"]
+    assert "omitted" in preview["notice"]
+    assert "T: raw/notebook" in preview["message"]
+    assert "O:" not in preview["message"]
+    assert file.reads == [(0, file.nbytes)]
+    from rich.console import Console
+
+    console = Console(record=True, width=100)
+    header, body = make_preview_renderables(preview)
+    with console.capture() as capture:
+        console.print(header, body)
+    rendered = capture.get()
+    assert "Title" in rendered
+    assert "Cell 2" in rendered
+    assert "evil()" not in rendered
+    raw = preview_file(file, raw=True)
+    assert "file_text" in raw
+    assert not raw["markdown"]
+
+
+def test_input_display_limits_and_unsupported_formats():
+    large = NotebookFile(notebook([]))
+    large.nbytes = NOTEBOOK_BYTES + 1
+    assert preview_file(large)["preview_status"] == "Preview unavailable"
+    assert not large.reads
+    cells = [{"cell_type": "raw", "source": "small"}] * (NOTEBOOK_CELLS + 1)
+    preview = preview_file(NotebookFile(notebook(cells)))
+    assert len(preview["notebook_cells"]) == NOTEBOOK_CELLS
+    assert "truncated" in preview["notice"]
+    for source in ("x" * (TEXT_BYTES + 1), "x\n" * (TEXT_LINES + 1)):
+        preview = preview_file(NotebookFile(notebook([{"cell_type": "raw", "source": source}])))
+        text = preview["notebook_cells"][0]["source"]
+        assert len(text.encode()) <= TEXT_BYTES
+        assert len(text.splitlines()) <= TEXT_LINES
+        assert "truncated" in preview["notice"]
+    assert preview_file(NotebookFile({"nbformat": 3}))["preview_status"] == "Preview unavailable"
+    assert preview_file(NotebookFile(notebook([])))["notebook_cells"] == []
+
+
+def test_plain_outputs_share_text_budget_and_strip_error_controls():
+    cells = [
+        {
+            "cell_type": "code",
+            "source": "print('x')",
+            "outputs": [{"output_type": "stream", "text": "y" * TEXT_BYTES}],
+        }
+    ]
+    preview = preview_file(NotebookFile(notebook(cells)))
+    cell = preview["notebook_cells"][0]
+    assert len((cell["source"] + cell["output"]).encode()) <= TEXT_BYTES
+    assert "truncated" in preview["notice"]
+    error = {
+        "cell_type": "code",
+        "source": "",
+        "outputs": [{"output_type": "error", "traceback": ["\x1b[31mValueError\x1b[0m", "details\0"]}],
+    }
+    preview = preview_file(NotebookFile(notebook([error])))
+    assert preview["notebook_cells"][0]["output"] == "ValueError\ndetails"
+
+
+def test_rich_only_outputs_and_unknown_language_are_not_interpreted():
+    data = notebook(
+        [
+            {
+                "cell_type": "code",
+                "source": "x",
+                "outputs": [
+                    {
+                        "output_type": "display_data",
+                        "data": {"image/png": "invalid base64", "text/html": "<script>evil()</script>"},
+                    }
+                ],
+            }
+        ]
+    )
+    data["metadata"]["language_info"]["name"] = "untrusted/custom/lexer"
+    preview = preview_file(NotebookFile(data))
+    assert preview["language"] == "text"
+    assert preview["notebook_cells"][0]["output"] == ""
+    assert "omitted" in preview["notice"]
+
+
+@pytest.mark.parametrize(
+    "invalid",
+    [
+        b"not JSON",
+        b'{"nbformat":4,"cells":"bad"}',
+        b'{"nbformat":4,"cells":[{"cell_type":"code","source":42}]}',
+    ],
+)
+def test_malformed_notebook_fails_without_crashing(invalid):
+    file = NotebookFile({})
+    file.data, file.nbytes = invalid, len(invalid)
+    assert preview_file(file)["preview_status"] == "Preview failed"
+
+
+@pytest.mark.parametrize("backend", ["local", "compressed", "memory"])
+def test_notebooks_on_direct_backends(tmp_path, backend):
+    payload = json.dumps(sample_notebook()).encode()
+    if backend == "memory":
+        fs = pytest.importorskip("fsspec").filesystem("memory")
+        source = "memory://b2view-notebooks/example.ipynb"
+        fs.pipe(source, payload)
+    elif backend == "compressed":
+        source = str(tmp_path / "example.ipynb.b2")
+        schunk = blosc2.SChunk(urlpath=source, mode="w", chunksize=4096, contiguous=True)
+        schunk.append_data(payload)
+        del schunk
+    else:
+        path = tmp_path / "example.ipynb"
+        path.write_bytes(payload)
+        source = str(path)
+    with StoreBrowser(source) as browser:
+        assert browser.kind("/") == "file"
+        assert len(browser.preview("/")["notebook_cells"]) == 3
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_caterva2_notebook_tui_and_raw_toggle(file_source):  # noqa: F811
+    from textual.widgets import Static
+
+    from blosc2.b2view.app import B2ViewApp
+
+    base, _, stats = file_source
+    payload = json.dumps(sample_notebook()).encode()
+    stream = blosc2.SChunk(chunksize=4096, cparams={"typesize": 1})
+    stream.append_data(payload)
+    stats["files"]["@public/example.ipynb"] = stream
+    stats["groups"]["@public"].append("example.ipynb")
+    app = B2ViewApp(base, start_path="/example.ipynb")
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(
+            pilot, lambda: "T: raw/notebook" in str(app.query_one("#data-header", Static).render())
+        )
+        assert app._selected_info.kind == "file"
+        assert not app._file_raw
+        await pilot.press("T")
+        await wait_until(pilot, lambda: "nbformat" in str(app.query_one("#preview", Static).render()))
+        assert app._file_raw
+        await pilot.press("T")
+        await wait_until(
+            pilot, lambda: "passive preview" in str(app.query_one("#data-header", Static).render())
+        )
+        assert not app._file_raw
+    app.wait_for_close()
diff --git a/tests/b2view/test_ordinary_files.py b/tests/b2view/test_ordinary_files.py
new file mode 100644
index 000000000..b83be0a42
--- /dev/null
+++ b/tests/b2view/test_ordinary_files.py
@@ -0,0 +1,369 @@
+"""Direct ordinary files share Caterva2's passive previews and explicit actions."""
+
+import functools
+import http.server
+import io
+import threading
+
+import numpy as np
+import pytest
+from tui_wait import wait_until
+
+import blosc2
+from blosc2.b2view.model import StoreBrowser
+from blosc2.b2view.ordinary_file import MAX_READ_BYTES, OrdinaryFile, local_path, ordinary_source
+
+
+@pytest.mark.parametrize("name", ["README.md", "a space.md", "literal%20.md", "café.md"])
+def test_local_file_url_roundtrip(tmp_path, name):
+    path = tmp_path / name
+    assert local_path(path.as_uri()) == path
+    assert local_path(path.as_uri().replace("file:///", "file://localhost/", 1)) == path
+    assert local_path(str(path)) == path
+
+
+@pytest.fixture
+def ordinary_http(tmp_path):
+    if blosc2.IS_WASM:
+        pytest.skip("emscripten cannot run a threaded HTTP server")
+
+    class Handler(http.server.SimpleHTTPRequestHandler):
+        def log_message(self, *args):
+            pass
+
+    server = http.server.ThreadingHTTPServer(
+        ("127.0.0.1", 0), functools.partial(Handler, directory=str(tmp_path))
+    )
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield f"http://127.0.0.1:{server.server_port}/"
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join()
+
+
+@pytest.mark.parametrize("backend", ["local", "file", "memory", "http"])
+def test_direct_file_metadata_preview_and_copy(tmp_path, ordinary_http, backend):
+    payload = b"# Hello\n\nOrdinary **Markdown**.\n"
+    path = tmp_path / "README.md"
+    path.write_bytes(payload)
+    if backend == "memory":
+        fs = pytest.importorskip("fsspec").filesystem("memory")
+        source = "memory://b2view-ordinary/README.md"
+        fs.pipe(source, payload)
+    else:
+        source = (
+            ordinary_http + path.name
+            if backend == "http"
+            else path.as_uri()
+            if backend == "file"
+            else str(path)
+        )
+    with StoreBrowser(source) as browser:
+        assert not browser.is_tree
+        assert browser.kind("/") == "file"
+        metadata = browser.get_info("/").metadata
+        assert metadata["name"] == "README.md"
+        assert metadata["nbytes"] == len(payload)
+        assert "cbytes" not in metadata
+        assert browser.preview("/")["markdown"]
+        assert not browser.preview("/", raw_text=True)["markdown"]
+        alias = browser.store.alias()
+    destination = tmp_path / "copy.md"
+    progress = []
+    alias.download(destination, progress=lambda done, total: progress.append((done, total)))
+    assert destination.read_bytes() == payload
+    assert progress[-1] == (len(payload), len(payload))
+    with pytest.raises(FileExistsError):
+        alias.download(destination)
+    alias.close()
+    with pytest.raises(RuntimeError, match="closed"):
+        alias.read_bytes(0, 1)
+
+
+def test_bounds_cancellation_and_size_changes(tmp_path):
+    source = tmp_path / "large.txt"
+    with source.open("wb") as stream:
+        stream.truncate(MAX_READ_BYTES + 1)
+    file = OrdinaryFile(source)
+    with pytest.raises(ValueError, match="16 MiB"):
+        file.read_bytes()
+    with pytest.raises(ValueError, match="interval"):
+        file.read_bytes(-1, 2)
+    assert file.read_bytes(4, 8) == b"\0" * 4
+    destination = tmp_path / "copy.txt"
+    with pytest.raises(InterruptedError):
+        file.download(destination, cancel=lambda: True)
+    assert not destination.exists()
+    assert not list(tmp_path.glob(".b2view-download-*"))
+    source.write_bytes(b"short")
+    with pytest.raises(OSError, match="short read"):
+        file.download(destination)
+    assert not destination.exists()
+    assert not list(tmp_path.glob(".b2view-download-*"))
+    with pytest.raises(ValueError, match="differ"):
+        file.download(source, overwrite=True)
+
+
+def test_preview_handles_partial_stream_reads(tmp_path, monkeypatch):
+    path = tmp_path / "text.txt"
+    path.write_bytes(b"hello world")
+    file = OrdinaryFile(path)
+
+    class Partial(io.BytesIO):
+        def read(self, size=-1):
+            return super().read(min(size, 2))
+
+    monkeypatch.setattr(file, "_stream", lambda **kwargs: Partial(b"hello world"))
+    assert file.read_bytes(0, 11) == b"hello world"
+
+
+def test_http_large_text_preview_remains_bounded(tmp_path, ordinary_http):
+    from blosc2.b2view.file_preview import TEXT_BYTES
+
+    (tmp_path / "large.txt").write_bytes(b"a" * (TEXT_BYTES * 8))
+    with StoreBrowser(ordinary_http + "large.txt") as browser:
+        preview = browser.preview("/")
+        assert len(preview["file_text"]) == TEXT_BYTES
+        assert "truncated" in preview["notice"]
+
+
+def test_empty_unknown_pdf_and_missing_files(tmp_path):
+    for name in ("empty.txt", "data.bin", "brochure.pdf"):
+        path = tmp_path / name
+        path.touch()
+        with StoreBrowser(str(path)) as browser:
+            result = browser.preview("/")
+            if name == "empty.txt":
+                assert result["file_text"] == ""
+            else:
+                assert result["preview_status"] == "Preview unavailable"
+            copy = tmp_path / ("copy-" + name)
+            browser.store.download(copy)
+            assert copy.read_bytes() == b""
+    with pytest.raises(FileNotFoundError):
+        StoreBrowser(str(tmp_path / "missing.txt"))
+    with pytest.raises(ValueError, match="regular file"):
+        OrdinaryFile(tmp_path)
+
+
+def test_chained_fsspec_file_and_storage_options(tmp_path, monkeypatch):
+    pytest.importorskip("fsspec")
+    import zipfile
+
+    from blosc2.b2view import ordinary_file
+
+    payload = b"# Archive member\n"
+    archive = tmp_path / "docs.zip"
+    with zipfile.ZipFile(archive, "w") as bundle:
+        bundle.writestr("notes/README.md", payload)
+    with StoreBrowser(f"zip://notes/README.md::{archive.as_uri()}") as browser:
+        assert browser.get_info("/").metadata["name"] == "README.md"
+        assert browser.preview("/")["file_text"] == payload.decode()
+        browser.store.download(tmp_path / "copied.md")
+    fs = pytest.importorskip("fsspec").filesystem("memory")
+    fs.pipe("memory://option-test/README.md", payload)
+    original = ordinary_file.fsspec_filesystem
+    seen = []
+
+    def filesystem(source, options):
+        seen.append(options)
+        return original(source, options)
+
+    monkeypatch.setattr(ordinary_file, "fsspec_filesystem", filesystem)
+    with StoreBrowser("memory://option-test/README.md", storage_options={"custom": "value"}):
+        assert seen
+        assert all(options == {"custom": "value"} for options in seen)
+
+
+def test_late_cancellation(tmp_path):
+    source = tmp_path / "source.txt"
+    source.write_bytes(b"hello")
+    file = OrdinaryFile(source)
+    destination = tmp_path / "destination.txt"
+    cancelled = False
+
+    def progress(done, total):
+        nonlocal cancelled
+        cancelled = True
+
+    with pytest.raises(InterruptedError):
+        file.download(destination, progress=progress, cancel=lambda: cancelled)
+    assert not destination.exists()
+    assert not list(tmp_path.glob(".b2view-download-*"))
+
+
+@pytest.mark.skipif(blosc2.IS_WASM, reason="emscripten has no hard links")
+def test_publication_race(tmp_path, monkeypatch):
+    source = tmp_path / "source.txt"
+    source.write_bytes(b"hello")
+    file = OrdinaryFile(source)
+    destination = tmp_path / "destination.txt"
+    original = __import__("os").link
+
+    def race(temporary, target):
+        destination.write_bytes(b"existing")
+        return original(temporary, target)
+
+    monkeypatch.setattr("os.link", race)
+    with pytest.raises(FileExistsError):
+        file.download(destination)
+    assert destination.read_bytes() == b"existing"
+    assert not list(tmp_path.glob(".b2view-download-*"))
+
+
+@pytest.mark.parametrize("competing_writer", [False, True])
+def test_wasm_download_publication(tmp_path, monkeypatch, competing_writer):
+    monkeypatch.setattr(blosc2, "IS_WASM", True)
+    source = tmp_path / "source.txt"
+    source.write_bytes(b"hello")
+    destination = tmp_path / "destination.txt"
+    file = OrdinaryFile(source)
+
+    def progress(done, total):
+        if competing_writer:
+            destination.write_bytes(b"existing")
+
+    if competing_writer:
+        with pytest.raises(FileExistsError):
+            file.download(destination, progress=progress)
+        assert destination.read_bytes() == b"existing"
+    else:
+        file.download(destination, progress=progress)
+        assert destination.read_bytes() == b"hello"
+        with pytest.raises(FileExistsError):
+            file.download(destination)
+    assert not list(tmp_path.glob(".b2view-download-*"))
+
+
+@pytest.mark.parametrize(
+    "source",
+    [
+        "a.b2nd",
+        "broken.b2z",
+        "a.h5/group",
+        "a.zarr",
+        "a.parquet",
+        "https://host/demo",
+        "https://host/demo/@public/README.md",
+        "memory://a.b2nd",
+        "zip://a.b2nd::memory://archive.zip",
+    ],
+)
+def test_dataset_and_service_routing_unchanged(source):
+    assert not ordinary_source(source)
+
+
+@pytest.mark.parametrize(
+    "source",
+    ["https://service.example.com", "https://service.example.com/", "http://service.example.com:8080"],
+)
+def test_bare_http_origins_keep_service_discovery(source):
+    assert not ordinary_source(source)
+    assert ordinary_source(source, remote_service="fsspec")
+    assert ordinary_source(source + "/README.md")
+
+
+def test_ipv6_http_and_explicit_fsspec_routing():
+    assert ordinary_source("http://[::1]/README.md")
+    assert ordinary_source("http://[::1]/no-extension", "fsspec")
+    assert ordinary_source("https://host/@public/README.md", "fsspec")
+
+
+def test_native_array_and_corrupt_dataset_keep_native_handling(tmp_path):
+    path = tmp_path / "array.b2nd"
+    blosc2.asarray(np.arange(10), urlpath=str(path))
+    with StoreBrowser(str(path)) as browser:
+        assert browser.kind("/") == "ndarray"
+    broken = tmp_path / "broken.b2nd"
+    broken.write_bytes(b"not a dataset")
+    with pytest.raises(RuntimeError):
+        StoreBrowser(str(broken))
+
+
+@pytest.mark.parametrize("backend", ["local", "memory"])
+def test_native_frames_with_nonstandard_names_still_open(tmp_path, backend):
+    array = blosc2.asarray(np.arange(10))
+    if backend == "memory":
+        fs = pytest.importorskip("fsspec").filesystem("memory")
+        source = "memory://b2view-ordinary/array.bin"
+        fs.pipe(source, array.to_cframe())
+    else:
+        path = tmp_path / "array"
+        path.write_bytes(array.to_cframe())
+        source = str(path)
+    with StoreBrowser(source) as browser:
+        assert browser.kind("/") == "ndarray"
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+@pytest.mark.parametrize("backend", ["local", "memory"])
+async def test_file_tui_toggle_copy_and_external_open(tmp_path, monkeypatch, backend):
+    from textual.widgets import Input, Static
+
+    from blosc2.b2view.app import B2ViewApp, FileTransferScreen
+
+    payload = b"# Hello\n\nLocal and remote files share the viewer."
+    if backend == "memory":
+        fs = pytest.importorskip("fsspec").filesystem("memory")
+        source = "memory://b2view-tui/README.md"
+        fs.pipe(source, payload)
+    else:
+        path = tmp_path / "README.md"
+        path.write_bytes(payload)
+        source = str(path)
+    launched = []
+    monkeypatch.setattr("blosc2.b2view.file_preview.open_external", launched.append)
+    app = B2ViewApp(source)
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(
+            pilot, lambda: "T: raw/Markdown" in str(app.query_one("#data-header", Static).render())
+        )
+        await pilot.press("T")
+        await wait_until(pilot, lambda: "# Hello" in str(app.query_one("#preview", Static).render()))
+        for external in (False, True):
+            app._file_action(external)
+            await wait_until(pilot, lambda: isinstance(app.screen, FileTransferScreen))
+            destination = tmp_path / ("opened.md" if external else "saved.md")
+            app.screen.query_one(Input).value = str(destination)
+            await pilot.press("enter")
+            await wait_until(
+                pilot, lambda: "Saved" in str(app.screen.query_one("#file-status", Static).render())
+            )
+            assert destination.read_bytes() == payload
+            await pilot.press("escape")
+        assert len(launched) == 1
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_local_image_uses_background_image_widget(tmp_path, monkeypatch):
+    from textual.widgets import Static
+
+    from blosc2.b2view.app import B2ViewApp
+
+    image = pytest.importorskip("PIL.Image")
+    path = tmp_path / "image.png"
+    image.new("RGB", (20, 10), "red").save(path)
+    monkeypatch.setattr("blosc2.b2view.app.TextualImage", lambda image: Static("Image"))
+    app = B2ViewApp(str(path))
+    async with app.run_test() as pilot:
+        await wait_until(pilot, lambda: bool(app.query_one("#file-image").children))
+        assert app._selected_info.kind == "file"
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_missing_local_file_exits_gracefully(tmp_path):
+    from blosc2.b2view.app import B2ViewApp
+
+    app = B2ViewApp(str(tmp_path / "missing.txt"))
+    async with app.run_test() as pilot:
+        await wait_until(pilot, lambda: app.return_code == 1)
+        assert "FileNotFoundError" in app.startup_error
+    app.wait_for_close()
diff --git a/tests/b2view/test_remote_compressed_files.py b/tests/b2view/test_remote_compressed_files.py
new file mode 100644
index 000000000..621783ff6
--- /dev/null
+++ b/tests/b2view/test_remote_compressed_files.py
@@ -0,0 +1,212 @@
+"""Range-only remote document carriers share native previews and transfers."""
+
+import http.server
+import io
+import json
+import struct
+import threading
+
+import numpy as np
+import pytest
+
+import blosc2
+from blosc2.b2view.compressed_file import CompressedFile
+from blosc2.b2view.model import StoreBrowser
+from blosc2.proxy_source import ByteRangeSChunkSource
+
+fsspec = pytest.importorskip("fsspec")
+
+
+def carrier(payload, chunksize=4096, **kwargs):
+    stream = blosc2.SChunk(chunksize=chunksize, cparams={"typesize": 1}, **kwargs)
+    for start in range(0, len(payload), chunksize):
+        stream.append_data(payload[start : start + chunksize])
+    return stream.to_cframe()
+
+
+@pytest.mark.parametrize("member", ["notes/README.md.b2", "README.md.b2"])
+def test_chained_document_uses_member_filename(tmp_path, member):
+    import zipfile
+
+    from blosc2.b2view.compressed_file import compressed_document
+
+    payload = b"# Archive document\n"
+    archive = tmp_path / "docs.zip"
+    with zipfile.ZipFile(archive, "w") as bundle:
+        bundle.writestr(member, carrier(payload))
+    source = f"zip://{member}::{archive.as_uri()}"
+    assert compressed_document(source)
+    file = CompressedFile(source)
+    try:
+        assert file.carrier == "README.md.b2"
+        assert file.name == "README.md"
+    finally:
+        file.close()
+    with StoreBrowser(source) as browser:
+        assert browser.get_info("/").metadata["name"] == "README.md"
+        assert browser.preview("/")["markdown"]
+        assert browser.preview("/")["file_text"] == payload.decode()
+        destination = tmp_path / browser.store.name
+        browser.store.download(destination)
+        assert destination.read_bytes() == payload
+
+
+def test_remote_text_preview_reads_only_needed_chunks(monkeypatch, tmp_path):
+    payload = b"a" * (256 << 10)
+    fs = fsspec.filesystem("memory")
+    fs.pipe("/remote-documents/README.md.b2", carrier(payload))
+    calls = []
+    original = ByteRangeSChunkSource.get_chunk
+
+    def chunk(source, index):
+        calls.append(index)
+        return original(source, index)
+
+    monkeypatch.setattr(ByteRangeSChunkSource, "get_chunk", chunk)
+    with StoreBrowser("memory:///remote-documents") as directory:
+        assert directory.list_children()[0].kind == "file"
+        info = directory.get_info("/README.md.b2")
+        assert info.metadata["carrier"] == "README.md.b2"
+        assert info.metadata["name"] == "README.md"
+        assert not calls
+        assert len(directory.preview("/README.md.b2")["file_text"]) == 64 << 10
+        assert calls == list(range(16))
+    file = CompressedFile("memory:///remote-documents/README.md.b2")
+    alias = file.alias()
+    file.close()
+    try:
+        destination = tmp_path / "README.md"
+        calls.clear()
+        alias.download(destination)
+        assert destination.read_bytes() == payload
+        assert calls == list(range(64))
+    finally:
+        alias.close()
+
+
+@pytest.mark.parametrize("name", ["empty.txt.b2", "doc.pdf.b2", "image.png.b2", "example.ipynb.b2"])
+def test_remote_document_previews(name):
+    if name.startswith("image"):
+        pil = pytest.importorskip("PIL.Image")
+        stream = io.BytesIO()
+        pil.new("RGB", (20, 10), "red").save(stream, format="PNG")
+        payload = stream.getvalue()
+    elif name.startswith("example"):
+        payload = json.dumps({"nbformat": 4, "cells": []}).encode()
+    else:
+        payload = b"%PDF-1.4\n" if name.startswith("doc") else b""
+    source = "memory:///remote-types/" + name
+    fsspec.filesystem("memory").pipe(source, carrier(payload))
+    with StoreBrowser(source) as browser:
+        preview = browser.preview("/")
+        if name.startswith("image"):
+            assert preview["file_image"].size == (20, 10)
+        elif name.startswith("example"):
+            assert preview["notebook_cells"] == []
+        elif name.startswith("doc"):
+            assert preview["preview_status"] == "Preview unavailable"
+        else:
+            assert preview["file_text"] == ""
+
+
+def test_remote_zero_chunks_and_nonzero_byte_ranges():
+    source = "memory:///zero.txt.b2"
+    payload = b"\0" * 10000
+    fsspec.filesystem("memory").pipe(source, carrier(payload))
+    file = CompressedFile(source)
+    try:
+        assert file.read_bytes(4090, 9000) == payload[4090:9000]
+    finally:
+        file.close()
+
+
+def test_remote_carriers_refuse_structural_metadata_and_large_chunks(monkeypatch):
+    fs = fsspec.filesystem("memory")
+    fs.pipe("/objects.txt.b2", carrier(b"bytes", meta={"b2o": {"kind": "object"}}))
+    with pytest.raises(ValueError, match="serialized object"):
+        CompressedFile("memory:///objects.txt.b2")
+    fs.pipe("/array.txt.b2", blosc2.asarray(np.arange(4)).to_cframe())
+    with pytest.raises(ValueError, match="SChunk"):
+        CompressedFile("memory:///array.txt.b2")
+    frame = bytearray(carrier(b"bytes"))
+    header_len = struct.unpack_from(">i", frame, 11)[0]
+    for position, value, limit in ((4, (256 << 20) + 1, "256 MiB"), (12, (32 << 20) + 1, "32 MiB")):
+        broken = frame.copy()
+        struct.pack_into("<I", broken, header_len + position, value)
+        fs.pipe("/large.txt.b2", broken)
+        file = CompressedFile("memory:///large.txt.b2")
+        with monkeypatch.context() as patch:
+            patch.setattr(
+                ByteRangeSChunkSource, "get_chunk", lambda *args: pytest.fail("Oversized payload fetched")
+            )
+            with pytest.raises(ValueError, match=limit):
+                file.read_bytes(0, 1)
+        file.close()
+
+
+@pytest.fixture
+def document_http():
+    if blosc2.IS_WASM:
+        pytest.skip("emscripten cannot run a threaded HTTP server")
+    state = {"frame": carrier(b"# Hello\n" * 10000), "mode": "range", "requests": []}
+
+    class Handler(http.server.BaseHTTPRequestHandler):
+        def log_message(self, *args):
+            pass
+
+        def do_HEAD(self):
+            self.send_response(200)
+            self.send_header("Content-Length", str(len(state["frame"])))
+            self.end_headers()
+
+        def do_GET(self):
+            value = self.headers.get("Range")
+            state["requests"].append((value, self.headers.get("Authorization")))
+            if state["mode"] == "ignore":
+                self.send_response(200)
+                self.send_header("Content-Length", str(len(state["frame"])))
+                self.end_headers()
+                return
+            start, stop = map(int, value.removeprefix("bytes=").split("-"))
+            data = state["frame"][start : stop + 1]
+            self.send_response(206)
+            span = f"bytes {start}-{stop}/{len(state['frame'])}"
+            self.send_header("Content-Range", "bytes 0-0/1" if state["mode"] == "wrong" else span)
+            self.send_header("Content-Length", str(len(data)))
+            self.end_headers()
+            self.wfile.write(data)
+
+    server = http.server.ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        yield f"http://127.0.0.1:{server.server_port}/README.md.b2?signature=test", state
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join()
+
+
+def test_http_document_ranges_and_transfer(document_http, tmp_path):
+    source, state = document_http
+    with StoreBrowser(source, storage_options={"headers": {"Authorization": "Bearer test"}}) as browser:
+        assert len(state["requests"]) == 2
+        assert browser.get_info("/").metadata["name"] == "README.md"
+        assert not state["requests"][0][0].endswith(str(len(state["frame"]) - 1))
+        assert browser.preview("/")["file_text"].startswith("# Hello")
+        alias = browser.store.alias()
+    try:
+        destination = tmp_path / "README.md"
+        alias.download(destination)
+        assert destination.read_bytes() == b"# Hello\n" * 10000
+    finally:
+        alias.close()
+    assert all(value and auth == "Bearer test" for value, auth in state["requests"])
+
+
+@pytest.mark.parametrize("mode", ["ignore", "wrong"])
+def test_http_document_refuses_non_range_servers(document_http, mode):
+    source, state = document_http
+    state["mode"] = mode
+    with pytest.raises(ValueError, match="byte-range support"):
+        StoreBrowser(source)
diff --git a/tests/b2view/test_startup_errors.py b/tests/b2view/test_startup_errors.py
new file mode 100644
index 000000000..1be57adbd
--- /dev/null
+++ b/tests/b2view/test_startup_errors.py
@@ -0,0 +1,153 @@
+"""Initial source failures terminate cleanly; errors in open sources do not."""
+
+import threading
+
+import httpx
+import pytest
+from test_remote_caterva2 import caterva2_source  # noqa: F401
+from tui_wait import wait_until
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_missing_caterva2_url_exits(caterva2_source):  # noqa: F811
+    from blosc2.b2view.app import B2ViewApp
+
+    base, _, _, _ = caterva2_source
+    app = B2ViewApp(base + "@public/numbers_color.b2")
+    async with app.run_test() as pilot:
+        await wait_until(pilot, lambda: app.return_code == 1)
+        assert app.startup_error == "b2view: Could not open source: HTTP 404 Not Found."
+        assert app.browser is None
+    assert app._closing
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+@pytest.mark.parametrize("close_error", [False, True])
+async def test_failed_initial_listing_closes_browser(monkeypatch, close_error):
+    from blosc2.b2view import app as app_module
+
+    closed = threading.Event()
+
+    class Browser:
+        is_tree = True
+
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def list_children(self, path):
+            raise OSError("Cannot list source")
+
+        def close(self):
+            closed.set()
+            if close_error:
+                raise OSError("Cleanup failed")
+
+    monkeypatch.setattr(app_module, "StoreBrowser", Browser)
+    app = app_module.B2ViewApp("https://host/@public")
+    async with app.run_test() as pilot:
+        await wait_until(pilot, lambda: app.return_code == 1)
+        assert closed.is_set()
+        assert "Cannot list source" in app.startup_error
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_leaf_failure_keeps_browser_running(caterva2_source):  # noqa: F811
+    from textual.widgets import Static
+
+    from blosc2.b2view.app import B2ViewApp
+
+    base, _, _, _ = caterva2_source
+    app = B2ViewApp(base, start_path="/mount/array")
+    async with app.run_test() as pilot:
+        await wait_until(pilot, lambda: app.table_page is not None)
+        app.update_panels("/missing")
+        await wait_until(pilot, lambda: "KeyError" in str(app.query_one("#metadata", Static).render()))
+        assert app.return_code is None
+        assert app.startup_error is None
+        app.update_panels("/mount/array")
+        await wait_until(pilot, lambda: app.table_page is not None)
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.parametrize("http_error", [False, True])
+def test_cli_failure_code_and_safe_error_output(monkeypatch, capsys, http_error):
+    from blosc2.b2view import app as app_module
+    from blosc2.b2view.cli import main
+
+    url = "https://user:password@host/@public/missing?token=secret"
+
+    def open_browser(*args, **kwargs):
+        if http_error:
+            response = httpx.Response(404, request=httpx.Request("GET", url))
+            response.raise_for_status()
+        raise OSError(f"Failed {url}; credential private-key\x1b[31m")
+
+    run = app_module.B2ViewApp.run
+    monkeypatch.setattr(app_module, "StoreBrowser", open_browser)
+    monkeypatch.setattr(app_module.B2ViewApp, "run", lambda app, **kwargs: run(app, headless=True))
+    code = main([url, "--profile", "private-key"])
+    captured = capsys.readouterr()
+    assert code == 1
+    assert "Could not open source" in captured.err
+    assert "HTTP 404" in captured.err if http_error else "OSError" in captured.err
+    for secret in ("password", "secret", "private-key", "\x1b[31m"):
+        assert secret not in captured.err
+    assert "Traceback" not in captured.err
+
+
+@pytest.mark.tui
+def test_missing_url_restores_real_terminal(caterva2_source):  # noqa: F811
+    import os
+    import select
+    import struct
+    import subprocess
+    import sys
+    import time
+
+    pty = pytest.importorskip("pty")
+    termios = pytest.importorskip("termios")
+    fcntl = pytest.importorskip("fcntl")
+    base, _, _, _ = caterva2_source
+    master, slave = pty.openpty()
+    fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", 40, 120, 1200, 800))
+    initial = termios.tcgetattr(slave)
+    process = None
+    screen = bytearray()
+    try:
+        process = subprocess.Popen(
+            [sys.executable, "-m", "blosc2.b2view.cli", base + "@public/numbers_color.b2"],
+            stdin=slave,
+            stdout=slave,
+            stderr=slave,
+            env={**os.environ, "TERM": "xterm-256color"},
+        )
+        deadline = time.monotonic() + 20
+        while process.poll() is None and time.monotonic() < deadline:
+            ready, _, _ = select.select([master], [], [], 0.1)
+            if ready:
+                screen.extend(os.read(master, 65536))
+        assert process.poll() is not None, "Invalid source left b2view running"
+        process.communicate(timeout=5)
+        while select.select([master], [], [], 0)[0]:
+            screen.extend(os.read(master, 65536))
+        stderr = screen.decode()
+        assert process.returncode == 1
+        assert "HTTP 404 Not Found" in stderr
+        assert "Traceback" not in stderr
+        assert termios.tcgetattr(slave) == initial
+        # Textual's terminal driver writes to stderr, not stdout.
+        assert "\x1b[?1049l" in stderr
+        assert stderr.rfind("\x1b[?1049l") < stderr.rfind("Could not open source")
+    finally:
+        if process is not None:
+            if process.poll() is None:
+                process.terminate()
+            process.communicate(timeout=5)
+        os.close(master)
+        os.close(slave)
diff --git a/tests/b2view/test_tree_search.py b/tests/b2view/test_tree_search.py
new file mode 100644
index 000000000..9d2c02777
--- /dev/null
+++ b/tests/b2view/test_tree_search.py
@@ -0,0 +1,246 @@
+"""Search uses listings only and preserves the navigation tree on dismissal."""
+
+from threading import RLock
+
+import pytest
+from test_remote_caterva2 import caterva2_source  # noqa: F401
+from tui_wait import wait_until
+
+from blosc2.b2view.model import NodeInfo
+from blosc2.b2view.tree_search import matching_nodes, search_tree
+
+
+class ListingBrowser:
+    def __init__(self):
+        self.io_lock = RLock()
+        self.calls = []
+        self.children = {
+            "/": [NodeInfo("/folder", "folder", "group", True), NodeInfo("/bad", "bad", "group", True)],
+            "/folder": [NodeInfo("/folder/README.md", "README.md", "file", False)],
+            "/bad": OSError("Cannot list directory"),
+        }
+
+    def list_children(self, path):
+        self.calls.append(path)
+        result = self.children[path]
+        if isinstance(result, Exception):
+            raise result
+        return result
+
+
+def test_discovered_filter_and_listing_only_search():
+    browser = ListingBrowser()
+    known = {"/": browser.children["/"]}
+    assert matching_nodes(known, "README") == []
+    assert not browser.calls
+    report = search_tree(browser, known, cancel=lambda: False)
+    assert browser.calls == ["/folder", "/bad"]
+    assert matching_nodes(report.listings, "readme")[0].path == "/folder/README.md"
+    assert matching_nodes(report.listings, "FOLDER/")[0].name == "README.md"
+    assert report.status == "Completed with listing errors"
+    assert len(report.errors) == 1
+    assert known == {"/": browser.children["/"]}
+
+
+@pytest.mark.parametrize(
+    ("limits", "status"),
+    [
+        ({"max_directories": 1}, "Directory limit reached"),
+        ({"max_nodes": 2}, "Node limit reached"),
+        ({"max_depth": 0}, "Depth limit reached"),
+    ],
+)
+def test_recursive_limits(limits, status):
+    browser = ListingBrowser()
+    report = search_tree(browser, {}, cancel=lambda: False, **limits)
+    assert report.status == status
+    assert browser.calls == ["/"]
+
+
+def test_recursive_cancellation():
+    browser = ListingBrowser()
+    report = search_tree(browser, {}, cancel=lambda: bool(browser.calls))
+    assert report.status == "Cancelled"
+    assert browser.calls == ["/"]
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_discovered_filter_makes_no_remote_requests_and_preserves_tree(caterva2_source):  # noqa: F811
+    from textual.widgets import Input, Tree
+
+    from blosc2.b2view.app import B2ViewApp
+    from blosc2.b2view.search_screen import TreeSearchScreen
+
+    base, _, _, stats = caterva2_source
+    app = B2ViewApp(base)
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(pilot, lambda: app._selected_info is not None)
+        tree = app.query_one("#tree", Tree)
+        selected = app.selected_path
+        children = tuple(tree.root.children)
+        before = repr(stats)
+        assert "f(ind)" in str(app.query_one("#tree-pane").border_subtitle)
+        tree.focus()
+        await pilot.press("f")
+        await wait_until(pilot, lambda: isinstance(app.screen, TreeSearchScreen))
+        app.screen.query_one(Input).value = "mount"
+        await pilot.pause()
+        assert "/mount" in app.screen.matches
+        assert repr(stats) == before
+        app.screen.query_one(Input).value = "nonexistent"
+        await pilot.pause()
+        assert not app.screen.matches
+        await pilot.press("escape")
+        assert app.selected_path == selected
+        assert tuple(tree.root.children) == children
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+@pytest.mark.parametrize("backend", ["local", "memory"])
+async def test_recursive_search_reveals_result(tmp_path, backend):
+    from textual.widgets import Button, Input, Static, Tree
+
+    from blosc2.b2view.app import B2ViewApp
+    from blosc2.b2view.search_screen import TreeSearchScreen
+
+    if backend == "memory":
+        fs = pytest.importorskip("fsspec").filesystem("memory")
+        source = "memory://b2view-search/root"
+        fs.pipe(source + "/deep/README.md", b"# Found")
+    else:
+        (tmp_path / "deep").mkdir()
+        (tmp_path / "deep/README.md").write_text("# Found")
+        source = str(tmp_path)
+    app = B2ViewApp(source)
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(pilot, lambda: app._selected_info is not None)
+        await pilot.press("ctrl+f")
+        await wait_until(pilot, lambda: isinstance(app.screen, TreeSearchScreen))
+        screen = app.screen
+        screen.query_one(Input).value = "readme"
+        await pilot.pause()
+        assert not screen.matches
+        screen.query_one("#tree-search-recursive", Button).press()
+        await wait_until(pilot, lambda: not screen.searching and "/deep/README.md" in screen.matches)
+        results = screen.query_one(Tree)
+        assert results.root.children[0].data == "/deep"
+        result = results.root.children[0].children[0]
+        results.select_node(result)
+        results.focus()
+        await pilot.press("enter")
+        await wait_until(pilot, lambda: not isinstance(app.screen, TreeSearchScreen))
+        await wait_until(pilot, lambda: app.selected_path == "/deep/README.md")
+        await wait_until(
+            pilot, lambda: "T: raw/Markdown" in str(app.query_one("#data-header", Static).render())
+        )
+        assert app._selected_info.kind == "file"
+        assert app.query_one("#tree", Tree).has_focus
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_dataset_search_selection_returns_focus_to_tree(tmp_path):
+    import numpy as np
+    from textual.widgets import Input, Tree
+
+    import blosc2
+    from blosc2.b2view.app import B2ViewApp
+    from blosc2.b2view.search_screen import TreeSearchScreen
+
+    blosc2.asarray(np.arange(10), urlpath=str(tmp_path / "array.b2nd"))
+    app = B2ViewApp(str(tmp_path))
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(pilot, lambda: app._selected_info is not None)
+        await pilot.press("ctrl+f")
+        await wait_until(pilot, lambda: isinstance(app.screen, TreeSearchScreen))
+        app.screen.query_one(Input).value = "array"
+        await pilot.pause()
+        results = app.screen.query_one(Tree)
+        results.select_node(results.root.children[0])
+        await wait_until(pilot, lambda: not isinstance(app.screen, TreeSearchScreen))
+        await wait_until(pilot, lambda: app.table_page is not None)
+        assert app.selected_path == "/array.b2nd"
+        assert app.query_one("#tree", Tree).has_focus
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_recursive_caterva2_search_does_not_fetch_array_values(caterva2_source):  # noqa: F811
+    from textual.widgets import Button, Input
+
+    from blosc2.b2view.app import B2ViewApp
+    from blosc2.b2view.search_screen import TreeSearchScreen
+
+    base, _, _, stats = caterva2_source
+    app = B2ViewApp(base)
+    async with app.run_test(size=(120, 40)) as pilot:
+        await wait_until(pilot, lambda: app._selected_info is not None)
+        await pilot.press("ctrl+f")
+        await wait_until(pilot, lambda: isinstance(app.screen, TreeSearchScreen))
+        screen = app.screen
+        screen.query_one(Input).value = "array"
+        screen.query_one("#tree-search-recursive", Button).press()
+        await wait_until(pilot, lambda: not screen.searching and "/mount/array" in screen.matches)
+        # Table classification may fetch an empty frame for schema discovery.
+        # No array values or nonempty table rows may be requested.
+        assert all(start == stop == 0 for start, stop in stats["ranges"])
+        assert app.selected_path == "/"
+        await pilot.press("escape")
+        before = repr(stats)
+        await pilot.press("ctrl+f")
+        await wait_until(pilot, lambda: isinstance(app.screen, TreeSearchScreen))
+        app.screen.query_one(Input).value = "array"
+        await pilot.pause()
+        assert "/mount/array" in app.screen.matches
+        assert repr(stats) == before
+        await pilot.press("escape")
+    app.wait_for_close()
+
+
+@pytest.mark.tui
+@pytest.mark.asyncio
+async def test_close_cancels_search_without_waiting_for_listing(tmp_path, monkeypatch):
+    import threading
+
+    from textual.widgets import Button
+
+    from blosc2.b2view.app import B2ViewApp
+    from blosc2.b2view.search_screen import TreeSearchScreen
+
+    (tmp_path / "deep").mkdir()
+    entered, release, finished = threading.Event(), threading.Event(), threading.Event()
+    app = B2ViewApp(str(tmp_path))
+    try:
+        async with app.run_test(size=(120, 40)) as pilot:
+            await wait_until(pilot, lambda: app._selected_info is not None)
+            original = app.browser.list_children
+
+            def slow(path):
+                entered.set()
+                try:
+                    assert release.wait(5)
+                    return original(path)
+                finally:
+                    finished.set()
+
+            monkeypatch.setattr(app.browser, "list_children", slow)
+            await pilot.press("ctrl+f")
+            await wait_until(pilot, lambda: isinstance(app.screen, TreeSearchScreen))
+            screen = app.screen
+            screen.query_one("#tree-search-recursive", Button).press()
+            await wait_until(pilot, entered.is_set)
+            await pilot.press("escape")
+            assert screen.cancelled.is_set()
+            assert not isinstance(app.screen, TreeSearchScreen)
+            assert app.selected_path == "/"
+            assert not finished.is_set()
+            release.set()
+            await wait_until(pilot, finished.is_set)
+    finally:
+        release.set()
+        app.wait_for_close()
diff --git a/tests/ctable/test_remote_parquet.py b/tests/ctable/test_remote_parquet.py
index 81188df5e..94eab2c69 100644
--- a/tests/ctable/test_remote_parquet.py
+++ b/tests/ctable/test_remote_parquet.py
@@ -148,6 +148,58 @@ def test_narrow_read_uses_only_one_later_group(tmp_path):
         assert remote.traffic.requests == before + 1
 
 
+@pytest.mark.parametrize("projected", [False, True])
+def test_empty_parquet_slice_is_metadata_only(tmp_path, monkeypatch, projected):
+    path = tmp_path / "dictionary.parquet"
+    source = pa.table({"id": range(12), "category": pa.array(["a", None, "b"] * 4).dictionary_encode()})
+    pq.write_table(source, path, row_group_size=3)
+    with blosc2.open(str(path), lazy=True, cache_policy=blosc2.CachePolicy.NONE) as remote:
+        table = remote.select(["category"]) if projected else remote
+
+        def forbidden(*args, **kwargs):
+            pytest.fail("Empty slice read Parquet data or enumerated live rows")
+
+        monkeypatch.setattr(remote_parquet.ParquetCache, "group", forbidden)
+        monkeypatch.setattr(CTable, "_live_positions_from_valid_rows_chunks", forbidden)
+        for empty in (table.slice(0, 0), table.take([])):
+            assert empty.nrows == 0
+            assert empty.col_names == table.col_names
+            assert schema_to_dict(empty._schema) == schema_to_dict(table._schema)
+            restored = blosc2.ctable_from_cframe(empty.to_cframe())
+            assert restored.nrows == 0
+            assert restored.col_names == table.col_names
+
+
+@pytest.mark.parametrize("projected", [False, True])
+def test_parquet_take_dictionary_reads_only_selected_groups(tmp_path, monkeypatch, projected):
+    path = tmp_path / "dictionary.parquet"
+    source = pa.table(
+        {
+            "id": range(9),
+            "category": pa.array(["a", "b", "a", "c", None, "c", "d", "e", "d"]).dictionary_encode(),
+        }
+    )
+    pq.write_table(source, path, row_group_size=3)
+    with blosc2.open(str(path), lazy=True, cache_policy=blosc2.CachePolicy.NONE) as remote:
+        table = remote.select(["category"]) if projected else remote
+        calls = []
+        original = remote_parquet.ParquetCache.group
+
+        def group(owner, number, physical):
+            calls.append((number, physical))
+            assert number == 1
+            return original(owner, number, physical)
+
+        monkeypatch.setattr(remote_parquet.ParquetCache, "group", group)
+        for result, positions in ((table.slice(3, 6), [3, 4, 5]), (table.take([5, 4, 3, 5]), [5, 4, 3, 5])):
+            expected = source.take(pa.array(positions))
+            if projected:
+                expected = expected.select(["category"])
+            assert result.to_arrow().to_pylist() == expected.to_pylist()
+            assert result._cols["category"].dictionary == ["c"]
+        assert calls
+
+
 @pytest.mark.parametrize(
     ("cells", "dtype"),
     [
diff --git a/tests/ctable/test_schema_compiler.py b/tests/ctable/test_schema_compiler.py
index 2d12c4341..4ea95c425 100644
--- a/tests/ctable/test_schema_compiler.py
+++ b/tests/ctable/test_schema_compiler.py
@@ -27,6 +27,49 @@
 # -------------------------------------------------------------------
 
 
+@pytest.mark.parametrize("marker", ["nan", "inf", "-inf"])
+def test_strict_json_nonfinite_schema_values(marker):
+    schema = schema_from_dict(
+        {
+            "version": 1,
+            "columns": [
+                {
+                    "name": "value",
+                    "kind": "float64",
+                    "nullable": True,
+                    "null_value": {"__float__": marker},
+                    "default": {"__float__": marker},
+                }
+            ],
+        }
+    )
+    spec = schema.columns[0].spec
+    if marker == "nan":
+        assert np.isnan(spec.null_value)
+        assert np.isnan(schema.columns[0].default)
+    else:
+        assert spec.null_value == float(marker)
+        assert schema.columns[0].default == float(marker)
+
+
+def test_strict_json_nonfinite_nested_schema():
+    from blosc2.schema_compiler import spec_from_metadata_dict
+
+    spec = spec_from_metadata_dict(
+        {
+            "kind": "list",
+            "item": {
+                "kind": "float32",
+                "nullable": True,
+                "null_value": {"__float__": "nan"},
+            },
+        }
+    )
+    assert np.isnan(spec.item_spec.null_value)
+    with pytest.raises(ValueError, match="Invalid non-finite"):
+        spec_from_metadata_dict({"kind": "float64", "null_value": {"__float__": "invalid"}})
+
+
 @dataclass
 class Simple:
     id: int = blosc2.field(blosc2.int64(ge=0))
diff --git a/tests/gateway_process.py b/tests/gateway_process.py
new file mode 100644
index 000000000..22449fbab
--- /dev/null
+++ b/tests/gateway_process.py
@@ -0,0 +1,54 @@
+"""Bounded startup and continuously drained output for gateway acceptance tests."""
+
+import subprocess
+import threading
+import time
+from collections import deque
+from contextlib import contextmanager
+from queue import Empty, Queue
+
+
+@contextmanager
+def gateway_process(command, timeout=20):
+    process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+    events = Queue()
+    logs = deque(maxlen=20)
+
+    def drain(stream, name):
+        for line in stream:
+            logs.append(f"{name}: {line[-2000:].rstrip()}")
+            if name == "stdout" and line.startswith("listening on "):
+                events.put(("ready", line.removeprefix("listening on ").strip()))
+        events.put(("closed", name))
+
+    threads = [
+        threading.Thread(target=drain, args=(stream, name), daemon=True)
+        for stream, name in ((process.stdout, "stdout"), (process.stderr, "stderr"))
+    ]
+    try:
+        deadline = time.monotonic() + timeout
+        for thread in threads:
+            thread.start()
+        while True:
+            try:
+                event, value = events.get(timeout=max(0, deadline - time.monotonic()))
+            except Empty:
+                raise TimeoutError("cat2lite startup timed out\n" + "\n".join(logs)) from None
+            if event == "ready":
+                yield value if value.startswith("http") else "http://" + value
+                break
+            if value == "stdout":
+                raise RuntimeError("cat2lite exited before listening\n" + "\n".join(logs))
+    finally:
+        if process.poll() is None:
+            process.terminate()
+        try:
+            process.wait(timeout=15)
+        except subprocess.TimeoutExpired:
+            process.kill()
+            process.wait(timeout=15)
+        for thread in threads:
+            if thread.ident is not None:
+                thread.join(timeout=5)
+        for stream in (process.stdout, process.stderr):
+            stream.close()
diff --git a/tests/test_caterva2_access.py b/tests/test_caterva2_access.py
new file mode 100644
index 000000000..1b5e05909
--- /dev/null
+++ b/tests/test_caterva2_access.py
@@ -0,0 +1,450 @@
+"""Service URL recognition and repository discovery (offline loopback fixtures)."""
+
+import pytest
+from test_remote_caterva2 import caterva2_source  # noqa: F401
+
+import blosc2
+from blosc2.caterva2_url import caterva2_urlpath
+
+
+@pytest.mark.parametrize(
+    ("url", "base", "path"),
+    [
+        ("http://localhost:8000/@public", "http://localhost:8000", "@public"),
+        ("http://[::1]:8000/demo/@public/a/", "http://[::1]:8000/demo", "@public/a"),
+        (
+            "https://host/deploy%20here/%40public/my%20array/@nested",
+            "https://host/deploy%20here",
+            "@public/my array/@nested",
+        ),
+    ],
+)
+def test_root_marker(url, base, path):
+    target = caterva2_urlpath(url)
+    assert target.urlbase == base
+    assert target.path == path
+
+
+@pytest.mark.parametrize(
+    "url", ["https://host/file.h5", "https://host/data?x=@public", "s3://bucket/@public/a"]
+)
+def test_ordinary_url(url):
+    assert caterva2_urlpath(url) is None
+
+
+@pytest.mark.parametrize(
+    "url",
+    [
+        "https://host/@",
+        "https://host/@public//a",
+        "https://host/../@public",
+        "https://host/@public/%2F",
+        "https://host/@public/%252F",
+        "https://host/@public/a%GG",
+        "https://host/@public/%FF",
+        "https://host/@public/a?x=1",
+        "https://host/@public/a#x",
+        "https://user:pass@host/@public",
+        "https://host/@public/a::/member",
+        "https://host/@public/%00",
+    ],
+)
+def test_unsafe_shorthand(url):
+    with pytest.raises((ValueError, UnicodeError)):
+        caterva2_urlpath(url)
+
+
+def test_shorthand_open(caterva2_source):  # noqa: F811
+    base, array, _, _ = caterva2_source
+    with blosc2.open(base + "@public/group") as group:
+        assert isinstance(group, blosc2.RemoteStore)
+        assert group.keys() == ["array", "table"]
+        with group["array"] as remote:
+            assert (remote[1:2, 2:4] == array[1:2, 2:4]).all()
+    with blosc2.open(base + "@public/table") as table:
+        assert isinstance(table, blosc2.RemoteCTable)
+        assert table.slice(0, 2).nrows == 2
+    assert isinstance(blosc2.open(base + "@public/group/array", lazy=False), blosc2.C2Array)
+
+
+def test_override_and_option_validation(monkeypatch):
+    monkeypatch.setattr(blosc2.schunk, "_open_fsspec_url", lambda *args: "ordinary-file")
+    assert blosc2.open("https://host/@public/data.b2nd", remote_service="fsspec") == "ordinary-file"
+    for options in ({"remote_service": "wrong"}, {"dataset": "a"}, {"hdf5_index": {}}):
+        with pytest.raises(ValueError):
+            blosc2.open("https://host/@public/a", **options)
+    with pytest.raises(ValueError):
+        blosc2.open(blosc2.URLPath("@public", urlbase="https://host"), remote_service="fsspec")
+
+
+def test_mount_expansion_is_lazy_and_memoized(caterva2_source):  # noqa: F811
+    base, array, _, stats = caterva2_source
+    with blosc2.open(base + "@public") as store:
+        assert stats["requests"] == ["/api/info/@public"]
+        assert dict(store.get_info().catalog_attrs) == {"note": "curated"}
+        assert dict(store.attrs) == {"name": "fixture"}
+        assert store.keys() == ["mount"]
+        assert "/api/list/@public/mount" not in stats["requests"]
+        with store["mount"] as mount:
+            assert mount.keys() == ["array", "empty", "table"]
+            assert mount.kind("array") == "ndarray"
+            with mount["empty"] as empty:
+                assert empty.keys() == []
+            before = stats["requests"].copy()
+            assert mount.keys() == ["array", "empty", "table"]
+            assert stats["requests"] == before
+        with store["mount/array"] as remote:
+            assert (remote[0:1, 0:2] == array[0:1, 0:2]).all()
+
+
+def test_direct_lookup_and_recursive_list(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    stats["groups"]["@public"] = ["mount/array", "mount/table", "mount/empty", "mount/array"]
+    with blosc2.open(base + "@public") as store:
+        assert store.kind("mount/array") == "ndarray"
+        assert not any("/api/list/" in request for request in stats["requests"])
+        assert store.keys() == ["mount"]
+        assert "/api/info/@public/mount/table" not in stats["requests"]
+        with store["mount"] as mount:
+            assert mount.keys() == ["array", "empty", "table"]
+
+
+def test_listing_failure_can_retry_and_limits_are_atomic(caterva2_source):  # noqa: F811
+    import httpx
+
+    base, _, _, stats = caterva2_source
+    with blosc2.RemoteStore(blosc2.URLPath("@public", urlbase=base), _max_nodes=5) as store:
+        assert store.keys() == ["mount"]
+        stats["fail_list"] = "@public/mount"
+        with store["mount"] as mount:
+            with pytest.raises(httpx.HTTPStatusError):
+                mount.keys()
+            stats["fail_list"] = None
+            previous = store._owner.nodes.copy()
+            with pytest.raises(ValueError, match="node limit"):
+                mount.keys()
+            assert store._owner.nodes == previous
+            stats["groups"]["@public/mount"] = ["empty"]
+            assert mount.keys() == ["empty"]
+
+
+def test_concurrent_expansion_is_coalesced(caterva2_source):  # noqa: F811
+    from concurrent.futures import ThreadPoolExecutor
+
+    base, _, _, stats = caterva2_source
+    with blosc2.open(base + "@public") as store, ThreadPoolExecutor(4) as executor:
+        results = list(executor.map(lambda _: store.keys(), range(12)))
+        assert results == [["mount"]] * 12
+        assert stats["requests"].count("/api/list/@public") == 1
+
+
+def test_bare_and_prefixed_service(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    for url in (base.rstrip("/"), base + "demo"):
+        with blosc2.open(url) as store:
+            assert isinstance(store, blosc2.RemoteStore)
+            assert not isinstance(store, blosc2.RemoteRepository)
+            assert store.keys() == ["mount"]
+    assert stats["requests"].count("/api/roots") == 2
+
+
+def test_repository_is_lazy_and_children_outlive_it(caterva2_source, tmp_path):  # noqa: F811
+    base, array, _, stats = caterva2_source
+    stats["roots"]["@broken"] = {"name": "@broken"}
+    repo = blosc2.open(base, cache_dir=tmp_path / "cache")
+    try:
+        assert isinstance(repo, blosc2.RemoteRepository)
+        assert repo.keys() == ["@broken", "@public"]
+        assert stats["requests"] == ["/api/roots"]
+        assert repo.kind("@broken") == "group"
+        with pytest.raises(KeyError):
+            repo["@broken"]
+        with repo[""] as alias:
+            child = alias["@public/mount/array"]
+            assert child is not None
+        with pytest.raises(NotImplementedError, match="persistence"):
+            repo.save(tmp_path / "repository.b2z")
+        assert repo.cache_policy is blosc2.CachePolicy.DISK
+        assert repo.cache_bytes == 0
+        assert "per root" in str(repo.info)
+    finally:
+        repo.close()
+    with child:
+        assert (child[0:1, 0:2] == array[0:1, 0:2]).all()
+    with pytest.raises(RuntimeError, match="closed"):
+        repo.keys()
+
+
+def test_empty_service_and_repository_option_validation(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    stats["roots"] = {}
+    with blosc2.open(base) as repo:
+        assert repo.keys() == []
+        assert repo.kind() == "group"
+    for options in (
+        {"lazy": False},
+        {"cache_path": "a.b2nd"},
+        {"shared_cache": True},
+        {"storage_options": {}, "remote_service": "caterva2"},
+    ):
+        with pytest.raises((ValueError, NotImplementedError)):
+            blosc2.open(base, **options)
+
+
+def test_direct_format_does_not_probe(monkeypatch):
+    monkeypatch.setattr(blosc2.schunk, "_open_fsspec_url", lambda *args: "ordinary-file")
+    monkeypatch.setattr(
+        blosc2.caterva2_url, "discover_service", lambda *args, **kwargs: pytest.fail("unexpected probe")
+    )
+    for url in (
+        "https://host/a.b2nd",
+        "https://host/a.b2",
+        "https://host/a.zarr/",
+        "https://host/a.h5::/group",
+        "https://host/a.b2z?version=2",
+    ):
+        assert blosc2.open(url) == "ordinary-file"
+
+
+@pytest.mark.parametrize("status", [401, 403, 500, 503])
+def test_discovery_preserves_http_failure(caterva2_source, status):  # noqa: F811
+    import httpx
+
+    base, _, _, stats = caterva2_source
+    stats["roots_status"] = status
+    with pytest.raises(httpx.HTTPStatusError) as error:
+        blosc2.open(base)
+    assert error.value.response.status_code == status
+    assert stats["requests"] == ["/api/roots"]
+
+
+@pytest.mark.parametrize("roots", [[], {"../evil": {}}, {"@public": "bad"}, {"@public": {"name": "other"}}])
+def test_invalid_discovery_falls_back_only_in_auto(caterva2_source, monkeypatch, roots):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    stats["roots"] = roots
+    monkeypatch.setattr(blosc2.schunk, "_open_fsspec_url", lambda *args: "ordinary-file")
+    assert blosc2.open(base) == "ordinary-file"
+    with pytest.raises(ValueError, match="roots response"):
+        blosc2.open(base, remote_service="caterva2")
+
+
+def test_discovery_redirects_timeout_and_response_limits(monkeypatch):
+    import httpx
+
+    from blosc2.caterva2_url import discover_service
+
+    cases = [
+        (
+            lambda request: httpx.Response(302, headers={"location": "https://elsewhere/api/roots"}),
+            ValueError,
+        ),
+        (lambda request: httpx.Response(200, content=b"x" * ((1 << 20) + 1)), ValueError),
+        (lambda request: httpx.Response(302, headers={"location": str(request.url)}), ValueError),
+    ]
+    for handler, error in cases:
+        with httpx.Client(transport=httpx.MockTransport(handler)) as client:
+            monkeypatch.setattr(blosc2.c2array, "_sync_client", lambda: client)
+            with pytest.raises(error):
+                discover_service("https://host/demo", auth_token="secret")
+
+    def timeout(request):
+        raise httpx.ReadTimeout("slow service", request=request)
+
+    with httpx.Client(transport=httpx.MockTransport(timeout)) as client:
+        monkeypatch.setattr(blosc2.c2array, "_sync_client", lambda: client)
+        with pytest.raises(httpx.ReadTimeout):
+            discover_service("https://host")
+
+    seen = []
+
+    def redirect(request):
+        seen.append(str(request.url))
+        return (
+            httpx.Response(302, headers={"location": "/demo/api/roots/"})
+            if len(seen) == 1
+            else httpx.Response(200, json={"@public": {"name": "@public"}})
+        )
+
+    with httpx.Client(transport=httpx.MockTransport(redirect)) as client:
+        monkeypatch.setattr(blosc2.c2array, "_sync_client", lambda: client)
+        assert discover_service("https://host/demo") == {"@public": {"name": "@public"}}
+    assert seen == ["https://host/demo/api/roots", "https://host/demo/api/roots/"]
+
+
+@pytest.mark.parametrize("encoding", ["gzip", "br", "deflate"])
+def test_discovery_rejects_encoding_before_reading(encoding, monkeypatch):
+    import httpx
+
+    from blosc2.caterva2_url import discover_service
+
+    class UnreadableStream(httpx.SyncByteStream):
+        def __iter__(self):
+            pytest.fail("Encoded response was read or decompressed")
+            yield b""  # Make this a stream iterator without reading any payload.
+
+    def respond(request):
+        assert request.headers["accept-encoding"] == "identity"
+        return httpx.Response(200, headers={"content-encoding": encoding}, stream=UnreadableStream())
+
+    with httpx.Client(transport=httpx.MockTransport(respond)) as client:
+        monkeypatch.setattr(blosc2.c2array, "_sync_client", lambda: client)
+        with pytest.raises(ValueError, match="Encoded"):
+            discover_service("https://host")
+
+
+@pytest.mark.parametrize("fragmented", [False, True])
+def test_discovery_checks_size_before_copying(fragmented, monkeypatch):
+    import httpx
+
+    import blosc2.caterva2_url as discovery
+
+    class BoundedPayload(bytearray):
+        def extend(self, data):
+            assert len(self) + len(data) <= 1 << 20, "Oversized fragment copied before checking"
+            super().extend(data)
+
+    class Fragments(httpx.SyncByteStream):
+        def __iter__(self):
+            if fragmented:
+                yield b" " * (1 << 19)
+                yield b" " * ((1 << 19) + 1)
+            else:
+                yield b" " * ((1 << 20) + 1)
+
+    monkeypatch.setattr(discovery, "bytearray", BoundedPayload, raising=False)
+    with httpx.Client(
+        transport=httpx.MockTransport(lambda _: httpx.Response(200, stream=Fragments()))
+    ) as client:
+        monkeypatch.setattr(blosc2.c2array, "_sync_client", lambda: client)
+        with pytest.raises(ValueError, match="exceeds 1 MiB"):
+            discovery.discover_service("https://host")
+
+
+def test_discovery_accepts_identity_at_exact_byte_limit(monkeypatch):
+    import httpx
+
+    from blosc2.caterva2_url import discover_service
+
+    payload = b"{}" + b" " * ((1 << 20) - 2)
+    with httpx.Client(
+        transport=httpx.MockTransport(
+            lambda _: httpx.Response(200, headers={"content-encoding": "identity"}, content=payload)
+        )
+    ) as client:
+        monkeypatch.setattr(blosc2.c2array, "_sync_client", lambda: client)
+        assert discover_service("https://host") == {}
+
+
+def test_repository_freezes_auth_context(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    stats["roots"]["@broken"] = {"name": "@broken"}
+    with blosc2.c2context(urlbase=base, auth_token="alice=secret"):
+        repo = blosc2.open(base)
+    with blosc2.c2context(auth_token="bob=secret"), repo:
+        with repo["@public"] as root:
+            assert root.keys() == ["mount"]
+    assert set(stats["cookies"]) == {"alice=secret"}
+
+
+@pytest.mark.parametrize(
+    ("destination", "expected"),
+    [
+        ("https://trusted/download", "secret"),
+        ("https://trusted:443/download", "secret"),
+        ("https://other/download", None),
+        ("http://trusted/download", None),
+        ("https://trusted:8443/download", None),
+    ],
+)
+def test_auto_discovery_scopes_ambient_credentials(destination, expected, monkeypatch):
+    import httpx
+
+    from blosc2.caterva2_url import discover_service
+
+    seen = []
+
+    def respond(request):
+        seen.append(request.headers.get("cookie"))
+        return httpx.Response(200, json={})
+
+    with httpx.Client(transport=httpx.MockTransport(respond)) as client:
+        monkeypatch.setattr(blosc2.c2array, "_sync_client", lambda: client)
+        with blosc2.c2context(urlbase="https://trusted", auth_token="secret"):
+            assert discover_service(destination) == {}
+            assert discover_service(destination, auth_token="explicit") == {}
+    assert seen == [expected, "explicit"]
+
+
+def test_discovered_foreign_repository_does_not_inherit_auth(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    stats["roots"]["@broken"] = {"name": "@broken"}
+    with blosc2.c2context(urlbase="https://trusted", auth_token="secret"):
+        with blosc2.open(base) as repo, repo["@public"] as root:
+            assert root.keys() == ["mount"]
+    assert not any(stats["cookies"])
+
+
+def test_nonlazy_groups_and_lookup_escaping_fail_clearly(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    with pytest.raises(NotImplementedError, match="requires lazy=True"):
+        blosc2.open(base + "@public", lazy=False)
+    with blosc2.open(base + "@public") as store:
+        before = stats["requests"].copy()
+        for path in ("mount/array?x=1", "mount/array#x", "mount/array%2F"):
+            with pytest.raises(ValueError, match="Unsafe"):
+                store.get_info(path)
+        assert stats["requests"] == before
+        with pytest.raises(KeyError):
+            store["nonexistent"]
+
+
+def test_old_catalog_listing_cache_is_rediscovered(caterva2_source, tmp_path):  # noqa: F811
+    base, _, _, _ = caterva2_source
+    cache = tmp_path / "cache"
+    with blosc2.open(base + "@public", cache_dir=cache) as store:
+        with store["mount"] as mount:
+            assert mount.keys() == ["array", "empty", "table"]
+        manifest = store._owner.disk.load()
+        manifest["metadata"].pop("caterva2_listing_version")
+        manifest["listed"]["@public/mount"] = []
+        store._owner.disk.publish(manifest)
+    with blosc2.open(base + "@public", cache_dir=cache) as reopened:
+        with reopened["mount"] as mount:
+            assert mount.keys() == ["array", "empty", "table"]
+
+
+def test_equivalent_openers_share_cache_identity_and_auth_does_not(caterva2_source, tmp_path):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    cache = tmp_path / "cache"
+    folders = []
+    for token, source in [
+        ("alice=secret", base + "@public/group"),
+        ("alice=secret", blosc2.URLPath("@public/group", urlbase=base)),
+        ("bob=secret", base + "@public/group"),
+    ]:
+        with blosc2.c2context(auth_token=token), blosc2.open(source, lazy=True, cache_dir=cache) as store:
+            folders.append(store._owner.disk.path)
+            with store["array"] as remote:
+                remote[:1, :2]
+    assert folders[0] == folders[1]
+    assert folders[0] != folders[2]
+    assert stats["fetches"] == 2
+
+
+def test_hierarchy_summary_isolates_failed_sources(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    stats["groups"]["@public/mount"].append("broken")
+    with blosc2.open(base + "@public") as store:
+        summary = str(store.info)
+        assert "listing incomplete" in summary
+        assert "[unavailable]" in summary
+        assert "array" in summary
+
+
+def test_default_discovery_limits(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    stats["groups"]["@public"] = ["mount/array"] * 100001
+    with blosc2.open(base + "@public") as store:
+        assert store._owner.max_nodes == 10000
+        with pytest.raises(ValueError, match="100000-entry"):
+            store.keys()
diff --git a/tests/test_caterva2_dtype.py b/tests/test_caterva2_dtype.py
new file mode 100644
index 000000000..cd3a7ee7d
--- /dev/null
+++ b/tests/test_caterva2_dtype.py
@@ -0,0 +1,124 @@
+"""Caterva2 dtype representations must agree with native b2nd decoding."""
+
+import numpy as np
+import pytest
+from test_remote_caterva2 import caterva2_source  # noqa: F401
+
+import blosc2
+from blosc2.b2view.model import StoreBrowser
+
+
+@pytest.mark.parametrize(
+    "dtype",
+    [
+        np.dtype("int32"),
+        np.dtype("S6"),
+        np.dtype("U6"),
+        np.dtype("complex128"),
+        np.dtype([("a", "<i4"), ("b", "<f8"), ("c", "S10"), ("d", "?")]),
+        np.dtype([("nested", [("x", "i4"), ("y", "f8")]), ("vector", "f4", (2, 3))]),
+        np.dtype([("byte", "u1"), ("number", "f8")], align=True),
+        np.dtype(("f8", (4,))),
+    ],
+)
+def test_c2array_dtype_repr(dtype):
+    array = object.__new__(blosc2.C2Array)
+    array.meta = {"dtype": str(dtype)}
+    assert array.dtype == dtype
+
+
+@pytest.mark.parametrize("dtype", ["not-a-dtype", "[('bad', 'not-a-dtype')]", "__import__('os').getcwd()"])
+def test_invalid_dtype_is_not_executed(dtype, monkeypatch):
+    import os
+
+    monkeypatch.setattr(os, "getcwd", lambda: pytest.fail("executed remote metadata"))
+    array = object.__new__(blosc2.C2Array)
+    array.meta = {"dtype": dtype}
+    with pytest.raises((TypeError, ValueError, SyntaxError)):
+        _ = array.dtype
+
+
+@pytest.mark.parametrize("shape", [(13,), (5, 7)])
+def test_structured_remote_array_and_browser(caterva2_source, shape):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    dtype = np.dtype([("a", "<i4"), ("b", "<f8"), ("c", "S10"), ("d", "?")])
+    data = np.zeros(shape, dtype=dtype)
+    data["a"] = np.arange(data.size).reshape(shape)
+    data["b"] = data["a"] / 10
+    data["c"] = b"foobar"
+    data["d"] = data["a"] % 2 == 0
+    chunks = (5,) if len(shape) == 1 else (3, 4)
+    blocks = (3,) if len(shape) == 1 else (2, 3)
+    source = blosc2.asarray(data, chunks=chunks, blocks=blocks)
+    key = "@public/structured"
+    stats["arrays"][key] = source
+    stats["groups"]["@public"].append("structured")
+    # Legacy info does not have an explicit kind; recognition must still work.
+    stats["array_metadata"][key] = {"kind": None}
+    with blosc2.C2Array(key, urlbase=base) as c2:
+        assert c2.dtype == dtype
+        np.testing.assert_array_equal(c2[:], data)
+    with blosc2.open(base + key) as remote:
+        assert remote.dtype == dtype
+        np.testing.assert_array_equal(remote[:], data)
+        np.testing.assert_array_equal(remote[2:8], data[2:8])
+    with StoreBrowser(base) as browser:
+        assert browser.get_info("/structured").metadata["dtype"] == str(dtype)
+        np.testing.assert_array_equal(browser._get_object("/structured")[:], data)
+        preview = browser.preview("/structured", max_rows=2, max_cols=2)
+        if len(shape) == 1:
+            np.testing.assert_array_equal(preview["data"]["value"], data[:2])
+        else:
+            np.testing.assert_array_equal(preview["data"]["0"], data[:2, 0])
+
+
+@pytest.mark.parametrize(("shape", "inner_shape"), [((13,), (4,)), ((5, 7), (2, 3))])
+def test_subarray_chunk_geometry(caterva2_source, shape, inner_shape):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    chunks = (5,) if len(shape) == 1 else (3, 4)
+    blocks = (3,) if len(shape) == 1 else (2, 3)
+    expanded_shape = (*shape, *inner_shape)
+    data = np.arange(np.prod(expanded_shape), dtype=np.float64).reshape(expanded_shape)
+    # HDF5 serves an expanded NDArray slice but describes a logical subarray dtype.
+    source = blosc2.asarray(data, chunks=(*chunks, *inner_shape), blocks=(*blocks, *inner_shape))
+    key = "@public/subarray"
+    stats["arrays"][key] = source
+    stats["array_metadata"][key] = {
+        "dtype": str(np.dtype(("f8", inner_shape))),
+        "shape": shape,
+        "chunks": chunks,
+        "blocks": blocks,
+    }
+    stats["groups"]["@public"].append("subarray")
+    with blosc2.open(base + key) as remote:
+        assert remote.shape == shape
+        assert remote.dtype == np.dtype(("f8", inner_shape))
+        np.testing.assert_array_equal(remote[:], data)
+        np.testing.assert_array_equal(remote[2:4], data[2:4])
+    with StoreBrowser(base) as browser:
+        np.testing.assert_array_equal(browser._get_object("/subarray")[:], data)
+        preview = browser.preview("/subarray", max_rows=2, max_cols=2)
+        if len(shape) == 1:
+            np.testing.assert_array_equal(preview["data"]["value"], data[:2])
+        else:
+            np.testing.assert_array_equal(preview["data"]["0"], data[:2, 0])
+
+
+@pytest.mark.network
+@pytest.mark.parametrize(
+    "path",
+    [
+        "examples/ds-1d-fields.b2nd",
+        "examples/ds-2d-fields.b2nd",
+        "examples/sa-1M.b2nd",
+        "examples/hdf5root-example.h5/unsupported/compound-dtype",
+        "examples/hdf5root-example.h5/unsupported/array-dtype",
+    ],
+)
+def test_live_demo_dtype_previews(path):
+    with StoreBrowser("https://cat2.cloud/demo") as browser:
+        info = browser.get_info("/" + path)
+        assert info.kind == "ndarray"
+        preview = browser.preview("/" + path, max_rows=2, max_cols=2)
+        assert preview["stop"] == 2
+        assert len(preview["data"][preview["columns"][0]]) == 2
diff --git a/tests/test_caterva2_gateway.py b/tests/test_caterva2_gateway.py
new file mode 100644
index 000000000..d3f6dd244
--- /dev/null
+++ b/tests/test_caterva2_gateway.py
@@ -0,0 +1,206 @@
+"""Opt-in cross-project acceptance against an actual cat2lite server.
+
+Run with CAT2LITE_SERVER=/absolute/path/to/cat2lite-server in the blosc2 env.
+All upstream data is deterministic and served on loopback; no public network.
+"""
+
+import hashlib
+import json
+import os
+import subprocess
+import sys
+import threading
+from contextlib import contextmanager
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from urllib.parse import urlsplit
+
+import numpy as np
+import pytest
+from gateway_process import gateway_process
+
+import blosc2
+
+pytestmark = pytest.mark.skipif(
+    not os.environ.get("CAT2LITE_SERVER"), reason="set CAT2LITE_SERVER for gateway acceptance"
+)
+
+
+@contextmanager
+def gateway(base, catalog):
+    config = base / "server.toml"
+    config.write_text(
+        f'[server]\nlisten = "127.0.0.1:0"\npython = {json.dumps(sys.executable)}\n'
+        f"[remote]\ncache_dir = {json.dumps(str(base / 'server-cache'))}\n"
+    )
+    source_args = ["--data-dir", str(catalog)] if catalog.is_dir() else [str(catalog)]
+    with gateway_process([os.environ["CAT2LITE_SERVER"], "--config", str(config), *source_args]) as address:
+        yield address
+
+
+def test_real_cat2lite_schunk_file_download(tmp_path):
+    from blosc2.b2view.model import StoreBrowser
+
+    data = tmp_path / "files"
+    data.mkdir()
+    payload = b"ordinary file bytes\n" * 10
+    stream = blosc2.SChunk(chunksize=64, cparams={"typesize": 1})
+    for offset in range(0, len(payload), 64):
+        stream.append_data(payload[offset : offset + 64])
+    (data / "bytes.b2frame").write_bytes(stream.to_cframe())
+    with gateway(tmp_path, data) as url:
+        with StoreBrowser(url) as browser:
+            assert browser.kind("/bytes.b2frame") == "file"
+            assert browser.get_info("/bytes.b2frame").metadata["nbytes"] == len(payload)
+        with blosc2.open(url + "/@public/bytes.b2frame") as file:
+            assert file.read_bytes(61, 135) == payload[61:135]
+            file.download(tmp_path / "original.bin")
+            assert (tmp_path / "original.bin").read_bytes() == payload
+
+
+def test_real_catalog_browsing_and_shared_server_cache(tmp_path):
+    h5py = pytest.importorskip("h5py")
+    zarr = pytest.importorskip("zarr")
+    pa = pytest.importorskip("pyarrow")
+    pq = pytest.importorskip("pyarrow.parquet")
+    from blosc2.b2view.model import StoreBrowser
+
+    data = tmp_path / "upstream"
+    data.mkdir()
+    expected = np.arange(60, dtype="i4").reshape(6, 10)
+    with h5py.File(data / "hierarchy.h5", "w") as file:
+        file.create_dataset("group/array", data=expected)
+        file.create_dataset("scalar", data=np.int32(42))
+    group = zarr.open_group(data / "hierarchy.zarr", mode="w", zarr_format=2)
+    group.create_array("group/array", data=expected, chunks=(3, 5))
+    zarr.consolidate_metadata(data / "hierarchy.zarr")
+    pq.write_table(
+        pa.table({"ident": list(range(20)), "value": [i * 3 for i in range(20)]}), data / "readings.parquet"
+    )
+    # Larger than small-source prefetch thresholds, with incompressible chunks.
+    large = np.random.default_rng(7).integers(0, 2**31, (1024, 1024), dtype="i4")
+    frame = blosc2.asarray(large, chunks=(128, 128), blocks=(32, 32)).to_cframe()
+    (data / "large.b2nd").write_bytes(frame)
+    files = {
+        "/" + path.relative_to(data).as_posix(): path.read_bytes()
+        for path in data.rglob("*")
+        if path.is_file()
+    }
+    stats = {"large_bytes": 0, "large_gets": 0}
+
+    class Source(BaseHTTPRequestHandler):
+        def serve(self, body):
+            path = urlsplit(self.path).path
+            if path not in files:
+                self.send_error(404)
+                return
+            payload = files[path]
+            length = len(payload)
+            offset, stop = 0, length
+            requested = self.headers.get("Range")
+            if requested:
+                start, _, end = requested.removeprefix("bytes=").partition("-")
+                offset = int(start) if start else max(0, length - int(end))
+                stop = min(length, int(end) + 1) if start and end else length
+            self.send_response(206 if requested else 200)
+            self.send_header("Content-Length", str(stop - offset))
+            self.send_header("Accept-Ranges", "bytes")
+            self.send_header("ETag", '"' + hashlib.sha256(payload).hexdigest() + '"')
+            if requested:
+                self.send_header("Content-Range", f"bytes {offset}-{stop - 1}/{length}")
+            self.end_headers()
+            if body:
+                if path == "/large.b2nd":
+                    stats["large_bytes"] += stop - offset
+                    stats["large_gets"] += 1
+                self.wfile.write(payload[offset:stop])
+
+        def do_GET(self):
+            self.serve(True)
+
+        def do_HEAD(self):
+            self.serve(False)
+
+        def log_message(self, *args):
+            pass
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Source)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        upstream = f"http://127.0.0.1:{server.server_port}"
+        catalog = tmp_path / "repo.catl"
+        catalog.write_text(
+            "entries:\n"
+            + "".join(
+                f"  {name}: {upstream}/{source}\n"
+                for name, source in [
+                    ("hdf5", "hierarchy.h5"),
+                    ("zarr", "hierarchy.zarr"),
+                    ("table", "readings.parquet"),
+                    ("large", "large.b2nd"),
+                ]
+            )
+        )
+        with gateway(tmp_path, catalog) as url:
+            with StoreBrowser(url) as browser:
+                assert [node.name for node in browser.list_children()] == ["hdf5", "large", "table", "zarr"]
+                assert browser.list_children("/hdf5")[0].name == "group"
+                assert browser.get_info("/hdf5/scalar").metadata["shape"] == ()
+                np.testing.assert_array_equal(
+                    browser.preview("/hdf5/group/array", slices=(slice(2), slice(3))), expected[:2, :3]
+                )
+                np.testing.assert_array_equal(
+                    browser.preview("/zarr/group/array", slices=(slice(2), slice(3))), expected[:2, :3]
+                )
+                assert list(browser.preview("/table", stop=3)["data"]["ident"]) == [0, 1, 2]
+            import asyncio
+
+            from blosc2.b2view.app import B2ViewApp
+
+            async def viewer_acceptance():
+                app = B2ViewApp(url, start_path="/hdf5/group/array")
+                async with app.run_test(size=(120, 40)) as pilot:
+                    for _ in range(200):
+                        if app.table_page and app.table_page["columns"]:
+                            break
+                        await pilot.pause(0.02)
+                    assert app.selected_path == "/hdf5/group/array"
+                    assert app.table_page
+                    assert app.table_page["columns"]
+                    np.testing.assert_array_equal(
+                        app.table_page["data"]["0"], expected[: app.table_page["stop"], 0]
+                    )
+                app.wait_for_close()
+
+            asyncio.run(viewer_acceptance())
+            code = """
+import sys
+import numpy as np
+import blosc2
+with blosc2.open(sys.argv[1] + '/@public/large', cache_policy=blosc2.CachePolicy.NONE) as array:
+    value = array[:2, :3]
+    assert value.shape == (2, 3)
+    print(value.tolist())
+"""
+
+            def independent_read():
+                result = subprocess.run(
+                    [sys.executable, "-c", code, url], capture_output=True, text=True, timeout=30
+                )
+                assert result.returncode == 0, result.stderr
+                assert json.loads(result.stdout) == large[:2, :3].tolist()
+
+            independent_read()
+            warm = stats.copy()
+            independent_read()
+            assert stats == warm, "second no-cache process should reuse server payload"
+            assert warm["large_bytes"] < large.nbytes // 2
+        with gateway(tmp_path, catalog) as url:
+            independent_read()
+            # A restart may re-read source headers, but not the warm data chunk.
+            assert stats["large_bytes"] - warm["large_bytes"] < 16 << 10
+        print("gateway cache evidence:", warm, "after restart:", stats)
+    finally:
+        server.shutdown()
+        server.server_close()
+        thread.join(timeout=5)
diff --git a/tests/test_gateway_process.py b/tests/test_gateway_process.py
new file mode 100644
index 000000000..41397be00
--- /dev/null
+++ b/tests/test_gateway_process.py
@@ -0,0 +1,39 @@
+"""Startup regressions use small Python children, without an external gateway."""
+
+import sys
+import time
+
+import pytest
+from gateway_process import gateway_process
+
+import blosc2
+
+pytestmark = pytest.mark.skipif(blosc2.IS_WASM, reason="emscripten cannot spawn processes")
+
+
+def test_startup_deadline_covers_partial_handshake():
+    script = "import time; print('starting', flush=True); time.sleep(60)"
+    start = time.monotonic()
+    with pytest.raises(TimeoutError, match="startup timed out"):
+        with gateway_process([sys.executable, "-c", script], timeout=0.5):
+            pytest.fail("Server was not ready")
+    assert time.monotonic() - start < 10
+
+
+def test_startup_drains_stderr_and_keeps_draining():
+    script = (
+        "import sys, time; "
+        "sys.stderr.write('x' * (1 << 20) + '\\n'); sys.stderr.flush(); "
+        "print('starting', flush=True); print('listening on 127.0.0.1:1234', flush=True); "
+        "sys.stderr.write('y' * (1 << 20) + '\\n'); sys.stderr.flush(); "
+        "time.sleep(60)"
+    )
+    with gateway_process([sys.executable, "-c", script], timeout=10) as address:
+        assert address == "http://127.0.0.1:1234"
+
+
+def test_startup_exit_before_readiness():
+    script = "import sys; print('startup failed', file=sys.stderr, flush=True)"
+    with pytest.raises(RuntimeError, match="exited before listening"):
+        with gateway_process([sys.executable, "-c", script], timeout=10):
+            pytest.fail("Server exited")
diff --git a/tests/test_remote_caterva2.py b/tests/test_remote_caterva2.py
index e6efe6eb8..160d3a627 100644
--- a/tests/test_remote_caterva2.py
+++ b/tests/test_remote_caterva2.py
@@ -51,6 +51,8 @@ def safe(value):
 
 @pytest.fixture
 def caterva2_source(request):
+    if blosc2.IS_WASM:
+        pytest.skip("emscripten cannot run a threaded HTTP server")
     array = blosc2.asarray(np.arange(60, dtype=np.int32).reshape(6, 10), chunks=(3, 5), blocks=(1, 5))
     nrows = getattr(request, "param", 12)
     if nrows in ("rich", "rich-large"):
@@ -84,9 +86,25 @@ def caterva2_source(request):
         "limit_rows": None,
         "fail_start": None,
         "short_start": None,
+        "requests": [],
+        "roots": {"@public": {"name": "@public"}},
+        "roots_status": 200,
+        "groups": {
+            "@public": ["mount"],
+            "@public/mount": ["array", "table", "empty"],
+            "@public/mount/empty": [],
+            "@public/group": ["array", "table"],
+        },
+        "fail_list": None,
+        "aliases": {},
+        "files": {},
+        "file_chunks": [],
+        "file_metadata": {},
+        "arrays": {},
+        "array_metadata": {},
     }
 
-    def array_info():
+    def array_info(array=array):
         return {
             "kind": "ndarray",
             "shape": array.shape,
@@ -97,7 +115,7 @@ def array_info():
             "schunk": {
                 "nbytes": array.nbytes,
                 "cbytes": array.cbytes,
-                "nchunks": 4,
+                "nchunks": array.schunk.nchunks,
                 "cparams": safe(array.cparams),
                 "vlmeta": {},
             },
@@ -130,35 +148,85 @@ def do_GET(self):
             stats["cookies"].append(self.headers.get("Cookie"))
             parsed = urllib.parse.urlsplit(self.path)
             path = urllib.parse.unquote(parsed.path)
+            path = path.removeprefix("/demo")
+            stats["requests"].append(path)
+            for endpoint in ("info", "list", "fetch"):
+                prefix = f"/api/{endpoint}/"
+                if path.startswith(prefix):
+                    key = path.removeprefix(prefix)
+                    path = prefix + stats["aliases"].get(key, key)
+                    break
+            if path == "/api/roots":
+                if stats["roots_status"] != 200:
+                    self.send_error(stats["roots_status"])
+                else:
+                    self.send(json.dumps(stats["roots"]).encode(), "application/json")
+                return
             if path.startswith("/api/info/"):
                 key = path.removeprefix("/api/info/")
-                if key == "@public/group":
-                    info = {"kind": "group", "attrs": {"name": "fixture"}}
-                elif key == "@public/group/array":
+                if key in stats["files"]:
+                    stream = stats["files"][key]
+                    info = {
+                        "nbytes": stream.nbytes,
+                        "cbytes": stream.cbytes,
+                        "nchunks": stream.nchunks,
+                        "chunksize": stream.chunksize,
+                        "cparams": safe(stream.cparams),
+                        "vlmeta": {"title": "ordinary file"},
+                    }
+                    info.update(stats["file_metadata"].get(key, {}))
+                elif key in stats["groups"]:
+                    info = {
+                        "kind": "group",
+                        "attrs": {"name": "fixture"},
+                        "catalog_attrs": {"note": "curated"},
+                    }
+                elif key in stats["arrays"]:
+                    info = array_info(stats["arrays"][key])
+                    info.update(stats["array_metadata"].get(key, {}))
+                elif key in {"@public/group/array", "@public/mount/array"}:
                     info = array_info()
-                elif key in {"@public/group/table", "@public/table"}:
+                elif key in {"@public/group/table", "@public/table", "@public/mount/table"}:
                     info = table_info()
                 else:
                     self.send_error(404)
                     return
                 self.send(json.dumps(info).encode(), "application/json")
                 return
-            if path == "/api/list/@public/group":
-                self.send(json.dumps(["array", "table"]).encode(), "application/json")
+            if path.startswith("/api/list/"):
+                key = path.removeprefix("/api/list/")
+                if key == stats["fail_list"]:
+                    self.send_error(503)
+                elif key in stats["groups"]:
+                    self.send(json.dumps(stats["groups"][key]).encode(), "application/json")
+                else:
+                    self.send_error(404)
                 return
+            if path.startswith("/api/chunk/"):
+                key = path.removeprefix("/api/chunk/")
+                if key in stats["arrays"]:
+                    index = int(urllib.parse.parse_qs(parsed.query)["nchunk"][0])
+                    self.send(stats["arrays"][key].schunk.get_chunk(index), "application/octet-stream")
+                    return
+                if key in stats["files"]:
+                    index = int(urllib.parse.parse_qs(parsed.query)["nchunk"][0])
+                    stats["file_chunks"].append((key, index))
+                    self.send(stats["files"][key].get_chunk(index), "application/octet-stream")
+                    return
             if path.startswith("/api/fetch/"):
                 stats["fetches"] += 1
                 key = path.removeprefix("/api/fetch/")
                 query = urllib.parse.parse_qs(parsed.query)
                 selection = query.get("slice_", [""])[0]
-                if key == "@public/group/array":
+                if key in stats["arrays"] or key in {"@public/group/array", "@public/mount/array"}:
+                    source = stats["arrays"].get(key, array)
                     axes = tuple(
                         slice(*(int(part) if part else None for part in axis.split(":")))
                         for axis in selection.split(",")
                     )
-                    self.send(array.slice(axes).to_cframe(), "application/octet-stream")
+                    self.send(source.slice(axes).to_cframe(), "application/octet-stream")
                     return
-                if key in {"@public/group/table", "@public/table"}:
+                if key in {"@public/group/table", "@public/table", "@public/mount/table"}:
                     start, stop = (int(part) for part in selection.split(":"))
                     stats["ranges"].append((start, stop))
                     if stats["fail_start"] == start:
diff --git a/tests/test_remote_file.py b/tests/test_remote_file.py
new file mode 100644
index 000000000..f6f6b6f6b
--- /dev/null
+++ b/tests/test_remote_file.py
@@ -0,0 +1,293 @@
+"""Deterministic Caterva2 ordinary-file byte transport and lifetime tests."""
+
+import pytest
+from test_remote_caterva2 import caterva2_source  # noqa: F401
+
+import blosc2
+
+
+@pytest.mark.parametrize("outcome", ["success", "failure", "cancel", "empty"])
+def test_chunk_traffic_counts_responses_not_fragments(outcome):
+    from types import SimpleNamespace
+
+    import httpx
+
+    from blosc2.proxy_source import Traffic
+
+    class Fragments(httpx.SyncByteStream):
+        def __iter__(self):
+            if outcome == "empty":
+                return
+            yield b"abc"
+            if outcome == "failure":
+                raise httpx.ReadError("broken stream")
+            yield b"defgh"
+
+    traffic = Traffic()
+    file = object.__new__(blosc2.RemoteFile)
+    file.path = "@public/README.md"
+    with httpx.Client(
+        transport=httpx.MockTransport(lambda _: httpx.Response(200, stream=Fragments()))
+    ) as client:
+        file._owner = SimpleNamespace(
+            caterva2=SimpleNamespace(urlbase="https://host", auth_token=""),
+            traffic=traffic,
+            transport=client,
+        )
+        if outcome in {"failure", "cancel"}:
+            error = httpx.ReadError if outcome == "failure" else InterruptedError
+            with pytest.raises(error):
+                file._fetch_chunk(0, lambda: outcome == "cancel")
+        else:
+            assert file._fetch_chunk(0, None) == (b"" if outcome == "empty" else b"abcdefgh")
+    assert traffic.requests == 1
+    assert traffic.nbytes == {"success": 8, "failure": 3, "cancel": 3, "empty": 0}[outcome]
+
+
+@pytest.fixture
+def file_source(caterva2_source):  # noqa: F811
+    base, _, _, stats = caterva2_source
+    payload = b"# Hello\n\nAn ordinary **Markdown** file.\n" * 20
+    stream = blosc2.SChunk(chunksize=64, cparams={"typesize": 1})
+    for offset in range(0, len(payload), 64):
+        stream.append_data(payload[offset : offset + 64])
+    stats["files"]["@public/README.md"] = stream
+    stats["groups"]["@public"].append("README.md")
+    return base, payload, stats
+
+
+@pytest.mark.parametrize("competing_writer", [False, True])
+@pytest.mark.parametrize("overwrite", [False, True])
+def test_wasm_remote_file_download_publication(tmp_path, monkeypatch, competing_writer, overwrite):
+    import threading
+    from types import SimpleNamespace
+
+    monkeypatch.setattr(blosc2, "IS_WASM", True)
+    file = object.__new__(blosc2.RemoteFile)
+    file._owner = SimpleNamespace(lock=threading.RLock())
+    file._meta = {"nchunks": 2, "nbytes": 5}
+    file._check_open = lambda: None
+    file._chunk = lambda index, cancel: [b"abc", b"de"][index]
+    destination = tmp_path / "download.txt"
+
+    def progress(done, total):
+        if competing_writer:
+            destination.write_bytes(b"existing")
+
+    if competing_writer and not overwrite:
+        with pytest.raises(FileExistsError):
+            file.download(destination, progress=progress)
+        assert destination.read_bytes() == b"existing"
+    else:
+        file.download(destination, overwrite=overwrite, progress=progress)
+        assert destination.read_bytes() == b"abcde"
+    assert not list(tmp_path.glob(".b2view-download-*"))
+    with pytest.raises(FileExistsError):
+        file.download(destination)
+
+
+def test_discovery_ranges_and_download(file_source, tmp_path):
+    base, payload, stats = file_source
+    with blosc2.open(base + "@public") as store:
+        assert store.kind("README.md") == "file"
+        assert not stats["file_chunks"]
+        with store["README.md"] as file:
+            assert isinstance(file, blosc2.RemoteFile)
+            assert file.name == "README.md"
+            assert file.attrs["title"] == "ordinary file"
+            assert file.read_bytes(59, 135) == payload[59:135]
+            assert file.read_bytes(1, 1) == b""
+            for start, stop in [(-1, 3), (4, 3), (True, 4), (0, len(payload) + 1)]:
+                with pytest.raises(ValueError):
+                    file.read_bytes(start, stop)
+            dest = tmp_path / "README.md"
+            progress = []
+            file.download(dest, progress=lambda done, total: progress.append((done, total)))
+            assert dest.read_bytes() == payload
+            assert progress[-1] == (len(payload), len(payload))
+            with pytest.raises(FileExistsError):
+                file.download(dest)
+            with pytest.raises(TypeError, match="bool"):
+                file.download(dest, overwrite="false")
+            with pytest.raises(NotImplementedError):
+                file.save(tmp_path / "file.b2z")
+
+
+@pytest.mark.parametrize(
+    "policy", [blosc2.CachePolicy.NONE, blosc2.CachePolicy.MEMORY, blosc2.CachePolicy.DISK]
+)
+def test_cache_and_child_lifetime(file_source, tmp_path, policy):
+    base, payload, stats = file_source
+    options = {"cache_policy": policy}
+    if policy is blosc2.CachePolicy.DISK:
+        options["cache_dir"] = tmp_path / "cache"
+    store = blosc2.open(base + "@public", **options)
+    file = store["README.md"]
+    store.close()
+    with file:
+        assert file.read_bytes(0, 10) == payload[:10]
+        before = len(stats["file_chunks"])
+        assert file.read_bytes(0, 10) == payload[:10]
+        assert len(stats["file_chunks"]) == before + (policy is blosc2.CachePolicy.NONE)
+    with pytest.raises(RuntimeError, match="closed"):
+        file.read_bytes(0, 1)
+    if policy is blosc2.CachePolicy.DISK:
+        with blosc2.open(base + "@public/README.md", **options) as direct:
+            assert direct.read_bytes(0, 10) == payload[:10]
+        # A different selected source has a distinct cache identity.
+        with blosc2.open(base + "@public", **options) as root, root["README.md"] as warm:
+            before = len(stats["file_chunks"])
+            warm.read_bytes(0, 10)
+            assert len(stats["file_chunks"]) == before
+
+
+def test_direct_file_and_cancelled_atomic_download(file_source, tmp_path):
+    base, payload, _ = file_source
+    dest = tmp_path / "test.md"
+    dest.write_bytes(b"old data")
+    with blosc2.open(base + "@public/README.md") as file:
+        assert file.read_bytes() == payload
+        with pytest.raises(InterruptedError):
+            file.download(dest, overwrite=True, cancel=lambda: True)
+        assert dest.read_bytes() == b"old data"
+        assert not list(tmp_path.glob(".b2view-download-*"))
+        with pytest.raises(NotImplementedError, match="lazy=True"):
+            blosc2.open(blosc2.URLPath("@public/README.md", urlbase=base))
+
+
+def test_metadata_validation(file_source):
+    base, _, stats = file_source
+    for overrides in ({"nbytes": True}, {"chunksize": 0}, {"nchunks": 999}, {"cparams": {"typesize": 0}}):
+        stats["file_metadata"]["@public/README.md"] = overrides
+        with pytest.raises(ValueError):
+            blosc2.open(base + "@public/README.md")
+
+
+def test_empty_file_and_metadata_only(file_source, tmp_path):
+    base, _, stats = file_source
+    stats["files"]["@public/empty.txt"] = blosc2.SChunk(chunksize=64, cparams={"typesize": 1})
+    with blosc2.open(base + "@public/empty.txt") as file:
+        assert file.read_bytes() == b""
+        file.download(tmp_path / "empty.txt")
+        assert (tmp_path / "empty.txt").read_bytes() == b""
+        assert not stats["file_chunks"]
+
+
+def test_download_publish_race_and_cancellation(file_source, tmp_path):
+    base, _, _ = file_source
+    dest = tmp_path / "race.md"
+    with blosc2.open(base + "@public/README.md") as file:
+        with pytest.raises(FileExistsError):
+            file.download(dest, progress=lambda *_: dest.write_bytes(b"concurrent creator"))
+        assert dest.read_bytes() == b"concurrent creator"
+        assert not list(tmp_path.glob(".b2view-download-*"))
+        cancelled = []
+        with pytest.raises(InterruptedError):
+            file.download(
+                dest,
+                overwrite=True,
+                cancel=lambda: bool(cancelled),
+                progress=lambda *_: cancelled.append(True),
+            )
+        assert dest.read_bytes() == b"concurrent creator"
+
+
+def test_corrupt_chunk_rejected_before_decompression(file_source, monkeypatch):
+    import struct
+
+    import httpx
+
+    base, _, _ = file_source
+    with blosc2.open(base + "@public/README.md", cache_policy=blosc2.CachePolicy.NONE) as file:
+        payload = b"\0" * 4 + struct.pack("<III", 1000000000, 32, 16)
+        with httpx.Client(
+            transport=httpx.MockTransport(lambda _: httpx.Response(200, content=payload))
+        ) as client:
+            file._owner.transport = client
+            monkeypatch.setattr(blosc2, "decompress", lambda *_: pytest.fail("unsafe decompression"))
+            with pytest.raises(ValueError, match="metadata"):
+                file.read_bytes(0, 1)
+
+
+def test_budget_eviction_and_refresh(file_source):
+    base, payload, stats = file_source
+    with blosc2.open(base + "@public", max_cache_bytes=80) as store:
+        file = store["README.md"]
+        assert file.read_bytes(0, 200) == payload[:200]
+        assert store.cache_bytes <= 80
+        store.refresh()
+        with pytest.raises(RuntimeError, match="stale"):
+            file.read_bytes(0, 1)
+        file.close()
+        with store["README.md"] as reopened:
+            assert reopened.read_bytes(0, 10) == payload[:10]
+    assert stats["file_chunks"]
+
+
+def test_response_bounds_and_auth_isolation(file_source, monkeypatch):
+    import httpx
+
+    base, _, stats = file_source
+    calls = []
+    for token in ("alice=secret", "bob=secret"):
+        with blosc2.c2context(auth_token=token), blosc2.open(base + "@public/README.md") as file:
+            file.read_bytes(0, 1)
+    assert set(stats["cookies"]) >= {"alice=secret", "bob=secret"}
+    assert len(stats["file_chunks"]) == 2
+    with blosc2.open(base + "@public/README.md", cache_policy=blosc2.CachePolicy.NONE) as file:
+
+        def handler(request):
+            calls.append(request)
+            return httpx.Response(200, headers={"content-length": str(33 << 20)}, content=b"small")
+
+        with httpx.Client(transport=httpx.MockTransport(handler)) as client:
+            file._owner.transport = client
+            with pytest.raises(ValueError, match="32 MiB"):
+                file.read_bytes(0, 1)
+        assert calls[-1].headers["Accept-Encoding"] == "identity"
+        file._meta.update(nbytes=257 << 20, chunksize=257 << 20, nchunks=1)
+        with pytest.raises(ValueError, match="256 MiB decoded"):
+            file.read_bytes(0, 1)
+
+
+def test_larger_decoded_chunks_keep_read_and_download_bounds(file_source, tmp_path):
+    base, _, stats = file_source
+    payload = b"a" * (17 << 20)
+    stream = blosc2.SChunk(chunksize=len(payload), cparams={"typesize": 1})
+    stream.append_data(payload)
+    stats["files"]["@public/large.txt"] = stream
+    with blosc2.open(base + "@public/large.txt") as file:
+        assert file.read_bytes(0, 64) == payload[:64]
+        with pytest.raises(ValueError, match="16 MiB"):
+            file.read_bytes(0, (16 << 20) + 1)
+        destination = tmp_path / "large.txt"
+        file.download(destination)
+        assert destination.read_bytes() == payload
+
+
+def test_old_unsupported_file_snapshot_is_rediscovered(file_source, tmp_path):
+    base, _, _ = file_source
+    options = {"cache_dir": tmp_path / "cache"}
+    with blosc2.open(base + "@public", **options) as store:
+        assert store.kind("README.md") == "file"
+        store._owner.save_manifest()
+        manifest = store._owner.disk.load()
+        manifest["nodes"]["@public/README.md"] = ["unsupported", "legacy"]
+        manifest["metadata"].pop("caterva2_files")
+        store._owner.disk.publish(manifest)
+    with blosc2.open(base + "@public", **options) as store:
+        assert store.kind("README.md") == "file"
+
+
+@pytest.mark.network
+def test_live_caterva2_demo_original_files(tmp_path):
+    base = "https://cat2.cloud/demo/@public/examples/"
+    for name, signature in (
+        ("README.md", b"#"),
+        ("Wutujing-River.jpg", b"\xff\xd8\xff"),
+        ("cat2cloud-brochure.pdf", b"%PDF-"),
+    ):
+        with blosc2.open(base + name) as file:
+            assert file.read_bytes(0, min(file.nbytes, 10)).startswith(signature)
+            file.download(tmp_path / name)
+            assert (tmp_path / name).stat().st_size == file.nbytes