s3dgraphy 1.6.0.dev84__tar.gz → 1.6.0.dev86__tar.gz

{s3dgraphy-1.6.0.dev84/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev86}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev84
+Version: 1.6.0.dev86
 Summary: 3D Stratigraphic Graph Management Library for archaeological and heritage applications
 Author-email: Emanuel Demetrescu <emanuel.demetrescu@cnr.it>
 Maintainer-email: Emanuel Demetrescu <emanuel.demetrescu@cnr.it>

{s3dgraphy-1.6.0.dev84 → s3dgraphy-1.6.0.dev86}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "s3dgraphy"
-version = "1.6.0.dev84"
+version = "1.6.0.dev86"
 description = "3D Stratigraphic Graph Management Library for archaeological and heritage applications"
 readme = "README.md"
 requires-python = ">=3.9"

{s3dgraphy-1.6.0.dev84 → s3dgraphy-1.6.0.dev86}/src/s3dgraphy/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "1.6.0.dev84"
+__version__ = "1.6.0.dev86"
 __datamodel_version__ = "1.5.5"  # s3Dgraphy connections datamodel version
 
 # s3Dgraphy/__init__.py

{s3dgraphy-1.6.0.dev84 → s3dgraphy-1.6.0.dev86}/src/s3dgraphy/resources/asset_list.py

@@ -65,6 +65,12 @@ TOOLS = ("decimate_bake", "gltfpack", "ktx2", "tileset", "instance", "keep")
 #: The states of an asset for a target.
 STATES = ("ok", "todo", "missing", "na")
 
+#: What a tileset's row says in the place of its level (MICRO-ARCHIVE-ASSET-3).
+TILESET_SAY = "tileset · in streaming"
+
+#: The targets a tileset streams to (the archive keeps its master).
+STREAMED = ("mobile", "web", "desk")
+
 #: A file this many triangles or more is a tileset's job, not a decimation's.
 TILESET_FROM = 2_000_000
 
@@ -147,7 +153,7 @@ def _state_of(graph, entry: Dict[str, Any], states: Dict[str, str]) -> str:
 
 
 def _version(graph, entry: Dict[str, Any], summary: Dict[str, Any], *, states, measure,
-             changed) -> Dict[str, Any]:
+             changed, tiles=None) -> Dict[str, Any]:
     from .graph_compose import level_say, made_by, made_by_say
     raw = None
     if measure is not None and not summary.get("tileset"):
@@ -159,10 +165,19 @@ def _version(graph, entry: Dict[str, Any], summary: Dict[str, Any], *, states, m
     ids = [entry["id"]] + [f["id"] for f in C._files(graph, entry) if f.get("id") != entry["id"]]
     now = next((changed[i] for i in ids if changed and i in changed), "")
     state = _state_of(graph, entry, states)
+    # MICRO-ARCHIVE-ASSET-3 · a tileset's tiles, each by its head (the caller
+    # reads them: ``tiles(entry)``); its row says «tileset · in streaming»
+    tstats = None
+    if summary.get("tileset") and tiles is not None and state != "in_cloud":
+        try:
+            tstats = tiles(entry)
+        except Exception:  # noqa: BLE001 — unreadable: not known
+            tstats = None
     return {"id": entry["id"], "name": summary.get("name") or entry.get("name") or "",
             "asset_id": entry.get("asset_id"), "master": bool(entry.get("master")),
             "level": summary.get("level") or "", "lod_level": summary.get("lod_level") or "",
-            "level_say": level_say(entry), "use": list(entry.get("use") or []),
+            "level_say": TILESET_SAY if summary.get("tileset") else level_say(entry),
+            "use": list(entry.get("use") or []),
             "url": summary.get("url") or "", "checksum": summary.get("checksum") or "",
             "stamped": bool(summary.get("checksum")),
             "size_bytes": summary.get("size_bytes"), "triangles": summary.get("triangles"),
@@ -183,7 +198,9 @@ def _version(graph, entry: Dict[str, Any], summary: Dict[str, Any], *, states, m
             "in_cloud": state == "in_cloud",
             "made": made, "made_say": made_by_say(made),
             "modified_after_stamp": bool(now) and not entry.get("master"), "sha256_now": now or "",
-            "loaded_by": []}
+            "loaded_by": [],
+            **({"tiles": {k: tstats.get(k) for k in ("tiles", "read", "max_triangles", "max_texture_side")},
+                "_tile_stats": tstats} if tstats else {})}
 
 
 # ── a target's state and proposal ───────────────────────────────────────────
@@ -318,21 +335,125 @@ def _targets(graph, row: Dict[str, Any], cand: Dict[str, Any], versions: List[Di
         st_a, why_a = "ok", "master timbrato e presente"
     out["arch"] = _target_cell("arch", state=st_a, loads=m["id"] if m else None, why=why_a,
                                source=src, kind=kind)
+
+    # MICRO-ARCHIVE-ASSET-3 · a tileset is «ok» for a target only if its
+    # tiles respect the target's band (per tile: triangles, texture side)
+    if tileset and lo:
+        from .tileset_fit import fit
+        tv = by.get(lo["id"]) or {}
+        for k in STREAMED:
+            f = fit(tv.get("_tile_stats"), bands(k))
+            if f["ok"]:
+                cell = _target_cell(k, state="ok", loads=lo["id"], why=f"in streaming: {f['why']}",
+                                    source=src, kind=kind)
+            elif f["known"]:
+                b = bands(k)
+                cell = _target_cell(k, state="todo", loads=lo["id"], why=f"le tile non rispettano la fascia: {f['why']}",
+                                    source=src, kind=kind)
+                cell["proposal"] = {"tool": "tileset", "triangles": b["object_triangles"],
+                                    "texture": b["object_texture_side"], "ktx2": k != "desk",
+                                    "why": (f"rifai le tile nella fascia ({b['object_triangles']:,} triangoli, "
+                                            f"{b['object_texture_side']} px per tile)").replace(",", ".")}
+            else:
+                cell = _target_cell(k, state="todo", loads=lo["id"], why=f["why"], source=src, kind=kind)
+                cell["proposal"] = {"tool": "keep", "triangles": None, "texture": None, "ktx2": False,
+                                    "why": "leggi le tile prima (il file del tileset su questo computer)"}
+            cell["tiles"] = {x: f[x] for x in ("ok", "known", "tiles", "read", "over_triangles", "over_texture",
+                                                "max_triangles", "max_texture_side")}
+            out[k] = cell
+    return out
+
+
+# ── MICRO-ARCHIVE-ASSET-3 · the tileset covers its meshes ───────────────────
+
+def _cited_alone(graph) -> Dict[str, str]:
+    """The nodes a narrative cites (an embed or a mention) → the narrative's
+    name: a mesh shown alone in a narrative is wanted one by one."""
+    try:
+        from ..narrative.query import citations
+        rows = citations(graph)
+    except Exception:  # noqa: BLE001 — no narrative layer: none cited
+        return {}
+    out: Dict[str, str] = {}
+    for r in rows:
+        out.setdefault(str(r.get("ref") or ""), str(r.get("narrative_name") or r.get("narrative_id") or ""))
     return out
 
 
+def cover_by_tilesets(graph, assets: List[Dict[str, Any]]) -> Dict[str, int]:
+    """A container whose tileset fits a target covers its meshes for it: each
+    says «coperta dal tileset di <contenitore>», has no proposal and is out
+    of the count (state ``na``, ``covered_by``). The exceptions, said and
+    left with their proposal: the container's meshes are of different epochs
+    («serve per epoca: il tileset non si divide»), or a mesh is cited alone in
+    a narrative. Where the tileset does not fit, the meshes keep their
+    proposal and say why the tileset does not cover them yet. → the meshes
+    covered per target."""
+    cited = None
+    n = {k: 0 for k in STREAMED}
+    for c in assets:
+        if c["kind"] != "container":
+            continue
+        tv = next((v for v in c["versions"] if v["tileset"] and v["id"] in
+                   {c["targets"][k]["loads"] for k in STREAMED}), None)
+        if tv is None:
+            continue
+        members = [a for a in assets if a is not c and a["kind"] == "rm"
+                   and any(x["id"] == c["id"] for x in a["containers"])]
+        if not members:
+            continue
+        if cited is None:
+            cited = _cited_alone(graph)
+        epochs = {tuple(sorted(a["epochs"])) for a in members}
+        by_epoch = len(epochs) > 1
+        for a in members:
+            alone = ("serve per epoca: il tileset non si divide" if by_epoch else
+                     f"usata da sola nella narrazione «{cited[a['id']]}»: il tileset non si divide"
+                     if a["id"] in cited else "")
+            for k in STREAMED:
+                tc, cell = c["targets"][k], a["targets"][k]
+                if cell["state"] == "na":
+                    continue
+                cell["tileset_of"] = {"id": c["id"], "name": c["name"], "state": tc["state"]}
+                if tc["state"] != "ok":
+                    cell["why"] = f"{cell['why']} (il tileset di {c['name']} non la copre: {tc['why']})"
+                    continue
+                if alone:
+                    cell["single"] = alone
+                    cell["why"] = f"{alone} — {cell['why']}"
+                    cell["proposal"] = {**cell["proposal"], "why": f"{alone} — {cell['proposal']['why']}"}
+                    continue
+                say = f"coperta dal tileset di {c['name']}"
+                for v in a["versions"]:
+                    if k in v["loaded_by"]:
+                        v["loaded_by"].remove(k)
+                a["targets"][k] = {"state": "na", "loads": cell["loads"], "why": say,
+                                   "covered_by": {"id": c["id"], "name": c["name"], "version": tv["id"]},
+                                   "tileset_of": cell["tileset_of"],
+                                   "proposal": {"tool": "keep", "triangles": None, "texture": None, "ktx2": False,
+                                                "why": say}}
+                n[k] += 1
+    return n
+
+
 # ── the list ─────────────────────────────────────────────────────────────────
 
 def asset_list(graph, *, states: Optional[Dict[str, str]] = None, measure=None,
                changed: Optional[Dict[str, str]] = None, in_room: bool = False,
-               models: Optional[Iterable[str]] = None, platform: str = "heriverse") -> Dict[str, Any]:
+               models: Optional[Iterable[str]] = None, platform: str = "heriverse",
+               tiles=None) -> Dict[str, Any]:
     """The assets of the study (``models``, default the published ones —
     representation models and the containers with a whole of their own),
     each with its versions (master first), their textures, its state and
     proposal per target (:data:`TARGETS`), the groups it belongs to
     (container, branch, epochs, family); the textures of the whole study once;
     the totals per target against the bands. → ``{targets, tools, assets,
-    textures, totals, counts, measured, estimated, say_it}``."""
+    textures, totals, counts, measured, estimated, say_it}``.
+
+    ``tiles(entry)`` (MICRO-ARCHIVE-ASSET-3, the caller's reader): a
+    tileset's tiles measured by their heads (:func:`.tileset_fit.measure_tiles`)
+    — the tileset is «ok» for a target only if they fit its band, and then it
+    covers its container's meshes (:func:`cover_by_tilesets`)."""
     from .alternatives import containers_of
     from .graph_compose import epochs_of
     states = dict(states or {})
@@ -349,7 +470,7 @@ def asset_list(graph, *, states: Optional[Dict[str, str]] = None, measure=None,
         versions = []
         for e in entries:
             s = C._summary(graph, e, measure)
-            v = _version(graph, e, s, states=states, measure=measure, changed=changed)
+            v = _version(graph, e, s, states=states, measure=measure, changed=changed, tiles=tiles)
             cache[e["id"]] = v
             versions.append(v)
             if not v["master"] and not v["tileset"]:
@@ -393,6 +514,10 @@ def asset_list(graph, *, states: Optional[Dict[str, str]] = None, measure=None,
                                    "level": v["level"] or ("master" if v["master"] else "")})
                 if t["name"] not in ti["names"]:
                     ti["names"].append(t["name"])
+    covered = cover_by_tilesets(graph, assets)
+    for a in assets:
+        for v in a["versions"]:
+            v.pop("_tile_stats", None)
     textures = sorted(tex_index.values(), key=lambda t: (-len(t["uses"]), -t["gpu_bytes"], t["name"]))
     for t in textures:
         t["count"] = len(t["uses"])
@@ -404,6 +529,7 @@ def asset_list(graph, *, states: Optional[Dict[str, str]] = None, measure=None,
               "textures": len(textures), "shared_textures": sum(1 for t in textures if t["count"] > 1),
               "measured": n_meas, "estimated": n_est,
               "in_cloud": sum(1 for a in assets for v in a["versions"] if v["in_cloud"]),
+              "covered_by_tileset": covered,
               "by_target": {k: {s: sum(1 for a in assets if a["targets"][k]["state"] == s) for s in STATES}
                             for k in TARGETS}}
     say = (f"{counts['assets']} asset ({counts['rms']} modelli, {counts['containers']} contenitori), "
@@ -432,6 +558,8 @@ def scene_totals(assets: Sequence[Dict[str, Any]], target: str) -> Dict[str, Any
     streamed = estimated = 0
     for a in assets:
         cell = a["targets"].get(target) or {}
+        if cell.get("covered_by"):
+            continue
         v = next((x for x in a["versions"] if x["id"] == cell.get("loads")), None)
         if v is None:
             continue

s3dgraphy-1.6.0.dev86/src/s3dgraphy/resources/tileset_fit.py

@@ -0,0 +1,144 @@
+"""Does a tileset fit a target? Its tiles measured one by one, from their
+heads only (MICRO-ARCHIVE-ASSET-3, E.D. 1 Nov 2026).
+
+E.D.: the tileset's row said «ok» for every target because «a tileset is its
+own lowest level»; it is «ok» for a target only if its TILES respect the
+target's band — texture and triangles per tile, read from the tileset.json or
+the .3tz without downloading all of it.
+
+A viewer streams a tileset tile by tile: what must fit the band per object is
+one tile (the triangles of its glb, the side of its largest texture), not the
+whole. Here each tile is read by its head: the b3dm / i3dm wrapper, the glb's
+JSON chunk (its accessors say the counts, a Draco primitive's too) and the
+first bytes of each image (its side) — never the geometry, never the pixels.
+
+Pure: the caller gives ``read_at(path, offset, length) -> bytes`` (a range of
+a file inside the tileset: a folder or a stored member of a .3tz) and the tree
+(:func:`.detail.read_tileset`). Nothing is written.
+"""
+
+from __future__ import annotations
+
+import json
+import struct
+from typing import Any, Callable, Dict, Iterable, List, Optional
+
+#: read_at(path inside the tileset, offset, length) -> the bytes (fewer at the end)
+ReadAt = Callable[[str, int, int], bytes]
+
+#: the bytes read of an image to know its side (a JPEG's SOF may follow EXIF)
+IMAGE_HEAD = 65536
+
+#: the tiles a model can carry (a .json is an external tileset, spliced)
+TILE_EXT = (".b3dm", ".i3dm", ".glb", ".gltf")
+
+
+def tile_head(read_at: ReadAt, path: str) -> Optional[Dict[str, Any]]:
+    """Triangles and texture side of ONE tile from its head → ``{triangles,
+    texture_side, texture_px, images}``; None when it is not a glb tile (a
+    point cloud, a composite) or cannot be read."""
+    from .use_profiles import image_size
+    try:
+        head = read_at(path, 0, 32)
+        if len(head) < 12:
+            return None
+        off = 0
+        if head[:4] == b"b3dm":
+            _m, _v, _len, ftj, ftb, btj, btb = struct.unpack("<4sIIIIII", head[:28])
+            off = 28 + ftj + ftb + btj + btb
+        elif head[:4] == b"i3dm":
+            hdr = struct.unpack("<4sIIIIIII", head[:32])
+            if hdr[7] != 1:          # a uri, not an embedded glb
+                return None
+            off = 32 + hdr[3] + hdr[4] + hdr[5] + hdr[6]
+        elif head[:4] != b"glTF":
+            return None
+        gh = read_at(path, off, 20)
+        if gh[:4] != b"glTF" or len(gh) < 20:
+            return None
+        jlen, jtyp = struct.unpack("<II", gh[12:20])
+        if jtyp != 0x4E4F534A:
+            return None
+        js = json.loads(read_at(path, off + 20, jlen).decode("utf-8"))
+        bin_at = off + 20 + jlen + 8          # the BIN chunk's data
+    except (ValueError, struct.error, OSError, UnicodeDecodeError):
+        return None
+    acc = js.get("accessors") or []
+    tris = 0
+    for mesh in js.get("meshes") or []:
+        for p in mesh.get("primitives") or []:
+            if p.get("mode", 4) != 4:
+                continue
+            pos = (p.get("attributes") or {}).get("POSITION")
+            nv = int(acc[pos]["count"]) if pos is not None and pos < len(acc) else 0
+            idx = p.get("indices")
+            tris += (int(acc[idx]["count"]) if idx is not None and idx < len(acc) else nv) // 3
+    side = px = 0
+    views = js.get("bufferViews") or []
+    for im in js.get("images") or []:
+        bv = im.get("bufferView")
+        if bv is None or bv >= len(views):
+            continue
+        v = views[bv]
+        try:
+            w, h, _f = image_size(read_at(path, bin_at + int(v.get("byteOffset") or 0),
+                                          min(int(v.get("byteLength") or 0), IMAGE_HEAD)))
+        except (OSError, struct.error):
+            w = h = 0
+        side = max(side, w, h)
+        px += w * h
+    return {"triangles": tris, "texture_side": side, "texture_px": px, "images": len(js.get("images") or [])}
+
+
+def tiles_of(tree: Dict[str, Any]) -> List[str]:
+    """The tiles of a tileset's tree (:func:`.detail.read_tileset`) that carry
+    a model, in the tree's order."""
+    return [n["uri"] for n in tree["nodes"].values()
+            if n.get("uri") and str(n["uri"]).lower().endswith(TILE_EXT)]
+
+
+def measure_tiles(tree: Dict[str, Any], read_at: ReadAt) -> Dict[str, Any]:
+    """Every tile of a tileset read by its head → ``{tiles, read, per_tile:
+    [[triangles, texture_side], …], max_triangles, max_texture_side}``
+    (``per_tile`` in the order of :func:`tiles_of`; a tile unread is left
+    out and counted in ``tiles - read``)."""
+    per: List[List[int]] = []
+    names = tiles_of(tree)
+    for p in names:
+        h = tile_head(read_at, p)
+        if h is not None:
+            per.append([int(h["triangles"]), int(h["texture_side"])])
+    return {"tiles": len(names), "read": len(per), "per_tile": per,
+            "max_triangles": max((x[0] for x in per), default=0),
+            "max_texture_side": max((x[1] for x in per), default=0)}
+
+
+def fit(stats: Optional[Dict[str, Any]], band: Dict[str, Any]) -> Dict[str, Any]:
+    """Do the tiles fit a band per object? → ``{ok, known, tiles, read,
+    over_triangles, over_texture, max_triangles, max_texture_side, why}``.
+    Unknown (``stats`` None, nothing read) is not ok: it is not known."""
+    obj, side = band.get("object_triangles"), band.get("object_texture_side")
+    if not stats or not stats.get("read"):
+        return {"ok": False, "known": False, "tiles": (stats or {}).get("tiles", 0), "read": 0,
+                "over_triangles": 0, "over_texture": 0, "max_triangles": None, "max_texture_side": None,
+                "why": "le tile non sono state lette: non si sa se rispettano la fascia"}
+    per: Iterable[List[int]] = stats.get("per_tile") or []
+    ot = sum(1 for t, _s in per if obj and t > obj)
+    ox = sum(1 for _t, s in per if side and s > side)
+    mt, ms = stats.get("max_triangles") or 0, stats.get("max_texture_side") or 0
+    n, r = int(stats.get("tiles") or 0), int(stats.get("read") or 0)
+    if not ot and not ox:
+        why = (f"le {r} tile rispettano la fascia (al più {mt:,} triangoli e {ms} px per tile)"
+               .replace(",", "."))
+        if r < n:
+            why += f"; {n - r} non lette"
+        return {"ok": True, "known": True, "tiles": n, "read": r, "over_triangles": 0, "over_texture": 0,
+                "max_triangles": mt, "max_texture_side": ms, "why": why}
+    parts = []
+    if ot:
+        parts.append(f"{ot} tile oltre {obj:,} triangoli (al più {mt:,})".replace(",", "."))
+    if ox:
+        parts.append(f"{ox} tile con texture oltre {side} px (al più {ms})")
+    return {"ok": False, "known": True, "tiles": n, "read": r, "over_triangles": ot, "over_texture": ox,
+            "max_triangles": mt, "max_texture_side": ms,
+            "why": f"su {r} tile: " + "; ".join(parts)}

{s3dgraphy-1.6.0.dev84 → s3dgraphy-1.6.0.dev86/src/s3dgraphy.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev84
+Version: 1.6.0.dev86
 Summary: 3D Stratigraphic Graph Management Library for archaeological and heritage applications
 Author-email: Emanuel Demetrescu <emanuel.demetrescu@cnr.it>
 Maintainer-email: Emanuel Demetrescu <emanuel.demetrescu@cnr.it>

{s3dgraphy-1.6.0.dev84 → s3dgraphy-1.6.0.dev86}/src/s3dgraphy.egg-info/SOURCES.txt

@@ -346,6 +346,7 @@ src/s3dgraphy/resources/resolver.py
 src/s3dgraphy/resources/s3_backend.py
 src/s3dgraphy/resources/storage_rows.py
 src/s3dgraphy/resources/tiles3tz.py
+src/s3dgraphy/resources/tileset_fit.py
 src/s3dgraphy/resources/use_profiles.py
 src/s3dgraphy/resources/versions.py
 src/s3dgraphy/room_import/__init__.py
@@ -607,6 +608,7 @@ tests/test_store_backed_geometry.py
 tests/test_stratiminer_api.py
 tests/test_study_metadata.py
 tests/test_threed_instances.py
+tests/test_tileset_fit.py
 tests/test_tileset_resource.py
 tests/test_transform_form.py
 tests/test_ttl_roundtrip.py

s3dgraphy-1.6.0.dev86/tests/test_tileset_fit.py

@@ -0,0 +1,142 @@
+"""MICRO-ARCHIVE-ASSET-3 (E.D. 1 Nov 2026) · a tileset is «ok» for a target
+only if its TILES fit the target's band (triangles and texture side per tile,
+read from their heads, never the geometry); then it covers its container's
+meshes — «coperte dal tileset di <contenitore>», no proposal, out of the
+count — unless they are wanted one by one (different epochs, a narrative that
+shows one alone). Its row says «tileset · in streaming»."""
+
+import json
+import struct
+
+from s3dgraphy.nodes.group_node import RepresentationModelNodeGroup
+from s3dgraphy.resources import asset_list as AL
+from s3dgraphy.resources import detail as D
+from s3dgraphy.resources import tileset_fit as F
+
+from tests.test_consolida_2 import _model, _png, _tileset_study
+
+
+def _glb(tris, sides):
+    """A glb with ``tris`` triangles (indices only: the accessors say the
+    count) and one PNG per side, in its BIN chunk."""
+    imgs = [_png(s, b"x") for s in sides]
+    views, binc = [], b""
+    for im in imgs:
+        views.append({"buffer": 0, "byteOffset": len(binc), "byteLength": len(im)})
+        binc += im + b"\0" * (-len(im) % 4)
+    js = {"asset": {"version": "2.0"}, "accessors": [{"count": 3, "type": "VEC3", "componentType": 5126},
+                                                     {"count": tris * 3, "type": "SCALAR", "componentType": 5125}],
+          "meshes": [{"primitives": [{"attributes": {"POSITION": 0}, "indices": 1}]}],
+          "bufferViews": views, "images": [{"bufferView": i, "mimeType": "image/png"} for i in range(len(imgs))],
+          "buffers": [{"byteLength": len(binc)}]}
+    j = json.dumps(js).encode()
+    j += b" " * (-len(j) % 4)
+    body = struct.pack("<II", len(j), 0x4E4F534A) + j + struct.pack("<II", len(binc), 0x004E4942) + binc
+    return b"glTF" + struct.pack("<II", 2, 12 + len(body)) + body
+
+
+def _b3dm(glb):
+    ft = b'{"BATCH_LENGTH":0}  '
+    return b"b3dm" + struct.pack("<IIIIII", 1, 28 + len(ft) + len(glb), len(ft), 0, 0, 0) + ft + glb
+
+
+def _tileset(tmp_path, tiles):
+    root = {"asset": {"version": "1.0"}, "geometricError": 10, "root": {
+        "boundingVolume": {"box": [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]}, "geometricError": 5, "refine": "REPLACE",
+        "children": [{"boundingVolume": {"box": [0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]}, "geometricError": 0,
+                      "content": {"uri": f"Data/t{i}.b3dm"}} for i in range(len(tiles))]}}
+    (tmp_path / "Data").mkdir()
+    (tmp_path / "tileset.json").write_text(json.dumps(root))
+    reads = []
+    for i, (tris, side) in enumerate(tiles):
+        (tmp_path / "Data" / f"t{i}.b3dm").write_bytes(_b3dm(_glb(tris, [side])))
+
+    def read_at(p, off, n):
+        reads.append(n)
+        with open(tmp_path / p, "rb") as fh:
+            fh.seek(off)
+            return fh.read(n)
+    lj, _sz, _rb = D.folder_loader(str(tmp_path))
+    return D.read_tileset(lj), read_at, reads
+
+
+def test_the_tiles_are_read_by_their_heads(tmp_path):
+    tree, read_at, reads = _tileset(tmp_path, [(9000, 512), (12000, 768), (100, 256)])
+    st = F.measure_tiles(tree, read_at)
+    assert (st["tiles"], st["read"], st["max_triangles"], st["max_texture_side"]) == (3, 3, 12000, 768)
+    assert sorted(map(tuple, st["per_tile"])) == [(100, 256), (9000, 512), (12000, 768)]
+    # never the geometry: the reads are the heads, the JSON and the images' first bytes
+    assert max(reads) <= F.IMAGE_HEAD
+    mob = F.fit(st, AL.bands("mobile"))
+    assert not mob["ok"] and mob["known"] and (mob["over_triangles"], mob["over_texture"]) == (1, 1)
+    assert "1 tile oltre 10.000 triangoli" in mob["why"]
+    web = F.fit(st, AL.bands("web"))
+    assert web["ok"] and "rispettano la fascia" in web["why"]
+    # not read is not ok: not known
+    assert F.fit(None, AL.bands("web")) == {**F.fit(None, AL.bands("web")), "ok": False, "known": False}
+
+
+def _study_with_members():
+    g, t = _tileset_study()
+    for rm in ("rm_rb1", "rm_rb2"):
+        g.add_edge(f"{rm}_in", rm, "grp", "is_in_representation_model_group")
+    return g, t
+
+
+def test_a_tileset_that_fits_covers_its_meshes_and_says_it_streams():
+    g, t = _study_with_members()
+    st = {"tiles": 4, "read": 4, "per_tile": [[9000, 512]] * 4, "max_triangles": 9000, "max_texture_side": 512}
+    out = AL.asset_list(g, tiles=lambda e: st)
+    a = {x["name"]: x for x in out["assets"]}
+    c = a["Survey2015"]
+    tv = next(v for v in c["versions"] if v["tileset"])
+    assert tv["level_say"] == "tileset · in streaming" and tv["tiles"]["tiles"] == 4 and "_tile_stats" not in tv
+    assert all(c["targets"][k]["state"] == "ok" for k in ("mobile", "web", "desk"))
+    for m in ("rm_rb1", "rm_rb2"):
+        cell = a[m]["targets"]["mobile"]
+        assert cell["state"] == "na" and cell["covered_by"]["name"] == "Survey2015"
+        assert cell["why"] == "coperta dal tileset di Survey2015" and cell["proposal"]["tool"] == "keep"
+    assert out["counts"]["covered_by_tileset"] == {"mobile": 2, "web": 2, "desk": 2}
+    # out of the count: the scene is the tileset (streamed) only
+    assert out["totals"]["web"]["triangles"] == 0 and out["totals"]["web"]["streamed"] == 1
+
+
+def test_a_tileset_over_the_band_or_unread_does_not_cover():
+    g, t = _study_with_members()
+    big = {"tiles": 2, "read": 2, "per_tile": [[9000, 1024], [9000, 512]], "max_triangles": 9000, "max_texture_side": 1024}
+    out = AL.asset_list(g, tiles=lambda e: big)
+    a = {x["name"]: x for x in out["assets"]}
+    mob = a["Survey2015"]["targets"]["mobile"]
+    assert mob["state"] == "todo" and mob["proposal"]["tool"] == "tileset" and mob["proposal"]["texture"] == 512
+    assert a["Survey2015"]["targets"]["web"]["state"] == "ok"
+    assert not a["rm_rb1"]["targets"]["mobile"].get("covered_by")
+    assert "il tileset di Survey2015 non la copre" in a["rm_rb1"]["targets"]["mobile"]["why"]
+    assert a["rm_rb1"]["targets"]["web"]["covered_by"]
+    # without a reader: not known — «da fare», nothing to queue until read
+    un = {x["name"]: x for x in AL.asset_list(g)["assets"]}["Survey2015"]["targets"]["web"]
+    assert un["state"] == "todo" and un["proposal"]["tool"] == "keep" and "non sono state lette" in un["why"]
+
+
+def test_meshes_wanted_one_by_one_keep_their_proposal_with_why():
+    from s3dgraphy.nodes.epoch_node import EpochNode
+    g, t = _study_with_members()
+    st = {"tiles": 1, "read": 1, "per_tile": [[10, 64]], "max_triangles": 10, "max_texture_side": 64}
+    # a narrative shows rb1 alone
+    from s3dgraphy.nodes.narrative_node import NarrativeNode
+    g.add_node(NarrativeNode(node_id="nar", name="Il podio", chapters=[
+        {"title": "1", "blocks": [{"block_type": "embed", "ref": "rm_rb1", "view_type": "rm"}]}]))
+    a = {x["name"]: x for x in AL.asset_list(g, tiles=lambda e: st)["assets"]}
+    c1 = a["rm_rb1"]["targets"]["web"]
+    assert c1["single"].startswith("usata da sola nella narrazione «Il podio»") and c1["state"] != "na"
+    assert "il tileset non si divide" in c1["proposal"]["why"]
+    assert a["rm_rb2"]["targets"]["web"]["covered_by"]
+    # different epochs among the container's meshes: all wanted one by one
+    g.add_node(EpochNode(node_id="e1", name="I sec", start_time=0, end_time=100))
+    g.add_node(EpochNode(node_id="e2", name="II sec", start_time=100, end_time=200))
+    g.add_edge("x1", "e1", "rm_rb1", "has_representation_model")
+    g.add_edge("x2", "e2", "rm_rb2", "has_representation_model")
+    a = {x["name"]: x for x in AL.asset_list(g, tiles=lambda e: st)["assets"]}
+    assert a["rm_rb1"]["epochs"] == ["I sec"] and a["rm_rb2"]["epochs"] == ["II sec"]
+    for m in ("rm_rb1", "rm_rb2"):
+        cell = a[m]["targets"]["web"]
+        assert not cell.get("covered_by") and cell["single"] == "serve per epoca: il tileset non si divide"