s3dgraphy 1.6.0.dev82__tar.gz → 1.6.0.dev84__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev82
+Version: 1.6.0.dev84
 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.dev82 → s3dgraphy-1.6.0.dev84}/pyproject.toml

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

{s3dgraphy-1.6.0.dev82 → s3dgraphy-1.6.0.dev84}/src/s3dgraphy/JSON_config/em_state_symbols.json

@@ -82,6 +82,18 @@
         "en": "A file is here but its bytes are zeros: an incomplete copy, to be made again."
       }
     },
+    "file.in_cloud": {
+      "family": "file",
+      "glyph": "⤓",
+      "label": {
+        "it": "nel cloud",
+        "en": "in the cloud"
+      },
+      "meaning": {
+        "it": "Il file è qui come segnaposto: i suoi byte sono nel cloud (OneDrive, iCloud, Dropbox «solo online»). Non si legge finché non lo scarichi.",
+        "en": "The file is here as a placeholder: its bytes are in the cloud (OneDrive, iCloud, Dropbox «online only»). It is not read until you download it."
+      }
+    },
     "node.reachable": {
       "family": "node",
       "glyph": "⬢",

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

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

{s3dgraphy-1.6.0.dev82 → s3dgraphy-1.6.0.dev84}/src/s3dgraphy/api.py

@@ -3246,9 +3246,11 @@ def resolve_files(graph: Graph, *, project_root: Optional[str] = None,
                   base_dirs: Sequence[str] = (), cache_dirs: Sequence[str] = (),
                   on_node: Optional[Callable[[str], bool]] = None,
                   hasher: Optional[Callable[[str], str]] = None,
-                  verify: bool = False) -> List[Dict[str, Any]]:
+                  verify: bool = False,
+                  cloud: Optional[Callable[[str], bool]] = None) -> List[Dict[str, Any]]:
     """The STATE of every resource of ``graph`` — ``on_disk``, ``on_node``,
-    ``both``, ``reference_only``, ``missing``, ``empty_copy`` — trying cache →
+    ``both``, ``reference_only``, ``missing``, ``empty_copy``, ``in_cloud``
+    (``cloud(path)``: bytes only in a cloud, never read) — trying cache →
     known paths (the EM standard tree of ``project_root`` first) → node
     (``on_node(hex)``) → reference. The one resolver every tool calls.
     ``verify`` (with a ``hasher``): a file here whose bytes are not the
@@ -3256,7 +3258,8 @@ def resolve_files(graph: Graph, *, project_root: Optional[str] = None,
     :mod:`s3dgraphy.resources.locate`."""
     from .resources.locate import resolve_graph
     return resolve_graph(graph, project_root=project_root, base_dirs=base_dirs,
-                         cache_dirs=cache_dirs, on_node=on_node, hasher=hasher, verify=verify)
+                         cache_dirs=cache_dirs, on_node=on_node, hasher=hasher, verify=verify,
+                         cloud=cloud)
 
 
 def resolve_file(entry: Dict[str, Any], **kwargs) -> Dict[str, Any]:

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

@@ -124,12 +124,23 @@ def _texture_rows(raw: Optional[Dict[str, Any]]) -> List[Dict[str, Any]]:
     return out
 
 
+def geometry_keys(raw: Optional[Dict[str, Any]]) -> List[str]:
+    """The ``geometry_key`` of each mesh of a measured file
+    (:func:`~.use_profiles.measure_gltf`), sorted, each once: two files with
+    the same keys hold the same geometry (the same topology and UVs), placed
+    anywhere. Empty when the file was not measured."""
+    if not raw or not isinstance(raw, dict):
+        return []
+    return sorted({str(o.get("geometry_key")) for o in raw.get("objects") or []
+                   if isinstance(o, dict) and o.get("geometry_key") and int(o.get("triangles") or 0) > 0})
+
+
 def _state_of(graph, entry: Dict[str, Any], states: Dict[str, str]) -> str:
     ids = [entry.get("id")] + [f["id"] for f in C._files(graph, entry) if f.get("id") != entry.get("id")]
     known = [states[i] for i in ids if i in states]
     if not known:
         return ""
-    for worst in ("missing", "empty_copy", "reference_only"):
+    for worst in ("missing", "empty_copy", "reference_only", "in_cloud"):
         if worst in known:
             return worst
     return known[0]
@@ -147,6 +158,7 @@ def _version(graph, entry: Dict[str, Any], summary: Dict[str, Any], *, states, m
     made = made_by(graph, entry["id"])
     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)
     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 "",
@@ -158,9 +170,17 @@ def _version(graph, entry: Dict[str, Any], summary: Dict[str, Any], *, states, m
             "texture_side": summary.get("texture_side"), "ktx2": summary.get("ktx2"),
             "tileset": bool(summary.get("tileset")),
             "textures": _texture_rows(raw),
+            # MICRO-ARCHIVE-ASSET-2 · the shape of the file: its meshes' geometry
+            # keys (indices and UVs, wherever placed — Draco/meshopt bytes when
+            # compressed) and its compression, for the forms repeated
+            "geometry_keys": geometry_keys(raw),
+            "compression": (raw.get("compression") or "") if isinstance(raw, dict) else "",
             "texture_count": len(raw.get("textures") or {}) if isinstance(raw, dict) else
             _data(_node(graph, entry["id"])).get("texture_count"),
-            "state": _state_of(graph, entry, states),
+            "state": state,
+            # MICRO-TESTATA-CLOUD · its bytes only in a cloud (not downloaded):
+            # never measured here, its numbers are the graph's estimate
+            "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": []}
@@ -288,6 +308,8 @@ def _targets(graph, row: Dict[str, Any], cand: Dict[str, Any], versions: List[Di
         st_a, why_a = "todo", "master senza sha256: timbralo"
     elif m["state"] in ("missing", "empty_copy", "reference_only"):
         st_a, why_a = "todo", f"il file del master non c'è ({m['state'].replace('_', ' ')})"
+    elif m["state"] == "in_cloud" and "tileset_master" not in codes:
+        st_a, why_a = "ok", "master timbrato, il file è nel cloud (non scaricato: non verificato)"
     elif "tileset_master" in codes:
         st_a, why_a = "todo", "dichiara il master del tileset (le mesh da cui viene)"
     elif not m["state"]:
@@ -348,6 +370,7 @@ def asset_list(graph, *, states: Optional[Dict[str, str]] = None, measure=None,
         br = branch_of(master["url"] if master else (versions[0]["url"] if versions else ""))
         modified = [v["id"] for v in versions if v["modified_after_stamp"]]
         missing_files = [v["id"] for v in versions if v["state"] in ("missing", "empty_copy")]
+        cloud_files = [v["id"] for v in versions if v["state"] == "in_cloud"]
         a = {"id": row["id"], "name": row["name"], "kind": row["kind"],
              "description": str(getattr(node, "description", "") or ""),
              "containers": conts, "branch": br, "epochs": [x["name"] for x in epochs_of(graph, row["id"])],
@@ -356,7 +379,7 @@ def asset_list(graph, *, states: Optional[Dict[str, str]] = None, measure=None,
              "loaded_why": row.get("loaded_why") or "", "loaded_say": row.get("loaded_say") or "",
              "tileset_master": row.get("tileset_master"),
              "audit": {"versions": len(versions), "stamped": sum(1 for v in versions if v["stamped"]),
-                       "files_missing": missing_files, "unchecked": sum(1 for v in versions if not v["state"]),
+                       "files_missing": missing_files, "files_in_cloud": cloud_files, "unchecked": sum(1 for v in versions if not v["state"]),
                        "modified_after_stamp": modified,
                        "master_declared": (row.get("tileset_master") or {}).get("declared")}}
         assets.append(a)
@@ -380,6 +403,7 @@ def asset_list(graph, *, states: Optional[Dict[str, str]] = None, measure=None,
               "versions": sum(len(a["versions"]) for a in assets),
               "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"]),
               "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), "
@@ -387,6 +411,8 @@ def asset_list(graph, *, states: Optional[Dict[str, str]] = None, measure=None,
            f"({counts['shared_textures']} condivise)")
     say += (f"; {n_meas} versioni misurate dai file, {n_est} stimate dal grafo" if n_est
             else f"; {n_meas} versioni misurate dai file")
+    if counts["in_cloud"]:
+        say += f"; {counts['in_cloud']} nel cloud (non scaricate: stimate dal grafo)"
     return {"targets": {k: {**{x: v for x, v in TARGETS[k].items() if x != "uses"},
                             "uses": list(TARGETS[k]["uses"]), "bands": bands(k)} for k in TARGETS},
             "tools": list(TOOLS), "assets": assets, "textures": textures, "totals": totals,

{s3dgraphy-1.6.0.dev82 → s3dgraphy-1.6.0.dev84}/src/s3dgraphy/resources/consolidate.py

@@ -357,7 +357,7 @@ def presence(graph, entry: Dict[str, Any], *, states: Optional[Dict[str, str]] =
     known = [states[i] for i in ids if i in states]
     state = known[0] if known else ""
     if len(known) > 1:
-        worst = next((s for s in ("missing", "empty_copy", "reference_only", "on_disk", "on_node")
+        worst = next((s for s in ("missing", "empty_copy", "reference_only", "in_cloud", "on_disk", "on_node")
                       if s in known), known[0])
         state = worst if not all(k == "both" for k in known) else "both"
     if not state:

{s3dgraphy-1.6.0.dev82 → s3dgraphy-1.6.0.dev84}/src/s3dgraphy/resources/locate.py

@@ -35,7 +35,7 @@ import re
 import urllib.parse
 from typing import Any, Callable, Dict, Iterable, List, Optional
 
-STATES = ("on_disk", "on_node", "both", "reference_only", "missing", "empty_copy")
+STATES = ("on_disk", "on_node", "both", "reference_only", "missing", "empty_copy", "in_cloud")
 
 #: the order the positions are tried in
 ORDER = ("cache", "path", "node", "reference")
@@ -136,7 +136,8 @@ def resolve(entry: Dict[str, Any], *, project_root: Optional[str] = None,
             base_dirs: Iterable[str] = (), cache_dirs: Iterable[str] = (),
             on_node: Optional[Callable[[str], bool]] = None,
             hasher: Optional[Callable[[str], str]] = None,
-            verify: bool = False) -> Dict[str, Any]:
+            verify: bool = False,
+            cloud: Optional[Callable[[str], bool]] = None) -> Dict[str, Any]:
     """The state of ONE resource. ``entry`` is ``{id, locator, checksum}`` (what
     :func:`entries_of` gives for a graph). The project's standard tree is tried
     before ``base_dirs`` (C1). ``hasher(path) -> hex`` lets a file found on the
@@ -146,7 +147,16 @@ def resolve(entry: Dict[str, Any], *, project_root: Optional[str] = None,
     the file was modified after its stamp (MICRO-CONSOLIDA-2) — the state
     stays where the bytes are.
 
-    → ``{id, sha256, state, path, positions: [{kind, where, ok}], note}``."""
+    ``cloud(path) -> bool`` (MICRO-TESTATA-CLOUD): a file whose bytes are
+    only in a cloud (OneDrive, iCloud, Dropbox «online only»: the caller
+    asks the system, by metadata). Such a file is NEVER read here — not
+    hashed, not probed for zeros — since reading it would download it: it is
+    said ``in_cloud`` with its place in ``cloud_path``, and ``path`` stays
+    empty, so nothing downstream measures it by accident. Another candidate
+    that is here wins over it.
+
+    → ``{id, sha256, state, path, positions: [{kind, where, ok}], note,
+    cloud_path?}``."""
     from ..project_tree import search_bases
 
     rid = str(entry.get("id") or "")
@@ -158,10 +168,20 @@ def resolve(entry: Dict[str, Any], *, project_root: Optional[str] = None,
     bases = (search_bases(project_root) if project_root else []) + \
         [b for b in (base_dirs or ()) if b]
     positions: List[Dict[str, Any]] = []
-    path, empty = None, None
+    path, empty, cloud_at = None, None, None
+
+    def in_cloud(p: str) -> bool:
+        if cloud is None:
+            return False
+        try:
+            return bool(cloud(p))
+        except Exception:  # noqa: BLE001 — a system that cannot say: not in the cloud
+            return False
 
     # 1 · cache
     hit = in_cache(cache_dirs, hexd)
+    if hit and in_cloud(hit):
+        cloud_at, hit = hit, None
     positions.append({"kind": "cache", "where": hit or "", "ok": bool(hit)})
     if hit:
         path = hit
@@ -188,13 +208,17 @@ def resolve(entry: Dict[str, Any], *, project_root: Optional[str] = None,
     if not path and cand_look and not cand_look.startswith(("blend://", "psx://")):
         for cand in local_candidates(cand_look, bases):
             if os.path.isfile(cand) or os.path.isdir(cand):
+                # in the cloud: never opened (a read would download it)
+                if os.path.isfile(cand) and in_cloud(cand):
+                    cloud_at = cloud_at or cand
+                    continue
                 if os.path.isfile(cand) and is_empty_copy(cand):
                     empty = empty or cand
                     continue
                 path = cand
                 break
-        positions.append({"kind": "path", "where": path or empty or cand_look,
-                          "ok": bool(path)})
+        positions.append({"kind": "path", "where": path or cloud_at or empty or cand_look,
+                          "ok": bool(path), **({"cloud": True} if cloud_at and not path else {})})
     elif locator.startswith(("blend://", "psx://")) and not look:
         positions.append({"kind": "path", "where": locator, "ok": None})
     changed, now = False, ""
@@ -229,8 +253,14 @@ def resolve(entry: Dict[str, Any], *, project_root: Optional[str] = None,
         state = "on_disk"
     elif node_has:
         state = "on_node"
-        if empty:
+        if cloud_at:
+            note = f"the copy here is in the cloud, not downloaded: {cloud_at}"
+        elif empty:
             note = f"the copy here is empty: {empty}"
+    elif cloud_at:
+        state = "in_cloud"
+        note = (f"in the cloud, not downloaded: {os.path.basename(cloud_at)} — "
+                f"download it to measure or verify it")
     elif empty:
         state = "empty_copy"
         note = (f"the bytes of {os.path.basename(empty)} are zeros: an incomplete copy "
@@ -243,6 +273,8 @@ def resolve(entry: Dict[str, Any], *, project_root: Optional[str] = None,
                 else "the graph does not say where the file is")
     out = {"id": rid, "sha256": f"sha256:{hexd}" if hexd else "", "state": state,
            "path": path or "", "positions": positions, "note": note}
+    if cloud_at and not path:
+        out["cloud_path"] = cloud_at
     if changed:
         out["changed"] = True
         out["sha256_now"] = f"sha256:{now}"
@@ -322,7 +354,7 @@ def resolve_graph(graph: Any, **kwargs) -> List[Dict[str, Any]]:
         if not states:
             continue
         rank = {s: i for i, s in enumerate(("missing", "empty_copy", "reference_only",
-                                             "on_node", "both", "on_disk"))}
+                                             "in_cloud", "on_node", "both", "on_disk"))}
         worst = min(states, key=lambda s: rank.get(s, 0))
         if all(s in ("on_disk", "both") for s in states):
             worst = "both" if all(s == "both" for s in states) else "on_disk"

{s3dgraphy-1.6.0.dev82 → s3dgraphy-1.6.0.dev84}/src/s3dgraphy/resources/use_profiles.py

@@ -52,7 +52,7 @@ import json
 import os
 import re
 import struct
-from typing import Any, Dict, Iterable, List, Optional, Sequence
+from typing import Any, Callable, Dict, Iterable, List, Optional, Sequence
 
 # ── the table ───────────────────────────────────────────────────────────────
 
@@ -1281,15 +1281,17 @@ def _stamp_of(path: str) -> Optional[str]:
     return sidecars(path)["stamp"]
 
 
-def list_versions(folder: str, model: Optional[str] = None, *, measure: bool = True
-                  ) -> List[Dict[str, Any]]:
+def list_versions(folder: str, model: Optional[str] = None, *, measure: bool = True,
+                  cloud: Optional[Callable[[str], bool]] = None) -> List[Dict[str, Any]]:
     """The versions in ``folder`` (``RB|SB/versions``), of ``model`` only when
     given: a ``.glb``/``.gltf`` named ``<model>@<level>-<destination>``, or a
     folder so named holding a ``.gltf`` (a glTF separate). Each →
     ``{name, model, level, destination, profile, entry, files, bytes,
     modified, stamp, triangles, textures}`` (the numbers read from the bytes
     when ``measure``); ``files`` are every file that goes with it (its .bin,
-    textures, its stamp) — what a removal deletes."""
+    textures, its stamp) — what a removal deletes. ``cloud(path) -> bool``
+    (MICRO-TESTATA-CLOUD): a file whose bytes are only in a cloud is not
+    measured (reading it would download it) — ``in_cloud`` on its row."""
     out = []
     try:
         names = sorted(os.listdir(folder))
@@ -1315,7 +1317,14 @@ def list_versions(folder: str, model: Optional[str] = None, *, measure: bool = T
                    modified=os.path.getmtime(entry))
         files: List[str] = []
         tris = textures = None
-        if measure and entry.endswith(".stl"):
+        try:
+            remote = bool(cloud(entry)) if cloud is not None else False
+        except Exception:  # noqa: BLE001 — a system that cannot say: not in the cloud
+            remote = False
+        if remote:
+            row["in_cloud"] = True
+            files = [entry]
+        elif measure and entry.endswith(".stl"):
             files = [entry]
             tris = stl_triangles(entry)
             textures = 0

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: s3dgraphy
-Version: 1.6.0.dev82
+Version: 1.6.0.dev84
 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.dev82 → s3dgraphy-1.6.0.dev84}/src/s3dgraphy.egg-info/SOURCES.txt

@@ -434,6 +434,7 @@ tests/test_canvas_metadata_import.py
 tests/test_capture_acquisition.py
 tests/test_capture_rdf_class.py
 tests/test_chronology_on_request.py
+tests/test_cloud_placeholders.py
 tests/test_coating_unit.py
 tests/test_composite_node_name.py
 tests/test_connection_resolver.py

{s3dgraphy-1.6.0.dev82 → s3dgraphy-1.6.0.dev84}/tests/test_asset_list.py

@@ -98,3 +98,15 @@ def test_the_audit_says_an_unstamped_master_and_a_file_modified_after_its_stamp(
     assert a["rm_lastra"]["targets"]["arch"]["why"].startswith("master senza sha256")
     assert a["rm_lastra"]["targets"]["web"]["state"] == "missing"
     assert api.asset_list(g)["counts"]["assets"] == 2
+
+
+def test_a_version_says_the_geometry_keys_of_its_file():
+    """MICRO-ARCHIVE-ASSET-2: the same geometry placed elsewhere keeps its
+    keys — the page gathers the forms repeated (a mesh shared + instances)."""
+    raw = {"objects": [{"name": "a", "triangles": 10, "geometry_key": "g:2"},
+                       {"name": "b", "triangles": 10, "geometry_key": "g:1"},
+                       {"name": "c", "triangles": 10, "geometry_key": "g:2"},
+                       {"name": "empty", "triangles": 0, "geometry_key": "g:0"}],
+           "compression": "draco"}
+    assert AL.geometry_keys(raw) == ["g:1", "g:2"]
+    assert AL.geometry_keys(None) == []

s3dgraphy-1.6.0.dev84/tests/test_cloud_placeholders.py

@@ -0,0 +1,86 @@
+"""MICRO-TESTATA-CLOUD (E.D. 1 Nov 2026) · a dataset in OneDrive, iCloud or
+Dropbox «online only»: the files are there as placeholders and reading one
+downloads it. The resolver is told by ``cloud(path)`` (the caller asks the
+system, by metadata) and never opens such a file: not hashed, not probed for
+zeros — it is ``in_cloud``, its place in ``cloud_path``, ``path`` empty so
+nothing measures it. Archive › Asset says it and estimates from the graph."""
+import hashlib
+
+from s3dgraphy import api
+from s3dgraphy.graph import Graph
+from s3dgraphy.resources import asset_list as AL
+from s3dgraphy.resources import locate as L
+
+from tests.test_consolida_2 import _model
+from tests.test_one_resolver import _project
+
+
+def test_a_file_in_the_cloud_is_never_read(tmp_path):
+    root = _project(tmp_path)
+    f = root / "EM" / "DosCo" / "D.01.jpg"
+    hexd = hashlib.sha256(f.read_bytes()).hexdigest()
+    read = []
+
+    def hasher(p):
+        read.append(p)
+        return hashlib.sha256(open(p, "rb").read()).hexdigest()
+    cloud = lambda p: p.endswith("D.01.jpg")                       # noqa: E731
+    r = L.resolve({"id": "a", "locator": "/DosCo/D.01.jpg", "checksum": f"sha256:{hexd}"},
+                  project_root=str(root), hasher=hasher, verify=True, cloud=cloud)
+    assert r["state"] == "in_cloud" and r["path"] == "" and r["cloud_path"].endswith("D.01.jpg")
+    assert "in the cloud" in r["note"] and read == []
+    # no digest recorded: still not hashed to ask the node
+    r = L.resolve({"id": "a", "locator": "/DosCo/D.01.jpg"}, project_root=str(root),
+                  hasher=hasher, on_node=lambda h: True, cloud=cloud)
+    assert r["state"] == "in_cloud" and read == []
+    # a zero placeholder in the cloud is not probed (that would download it)
+    r = L.resolve({"id": "e", "locator": "DosCo/D.02.jpg"}, project_root=str(root),
+                  cloud=lambda p: True)
+    assert r["state"] == "in_cloud"
+    # the node has it: on the node, the note says the copy here is in the cloud
+    r = L.resolve({"id": "a", "locator": "/DosCo/D.01.jpg", "checksum": f"sha256:{hexd}"},
+                  project_root=str(root), on_node=lambda h: True, cloud=cloud)
+    assert r["state"] == "on_node" and "cloud" in r["note"]
+    # without `cloud` nothing changes
+    assert L.resolve({"id": "a", "locator": "/DosCo/D.01.jpg"}, project_root=str(root))["state"] == "on_disk"
+    # a system that cannot say is «not in the cloud»
+    def boom(p):
+        raise OSError("no")
+    assert L.resolve({"id": "a", "locator": "/DosCo/D.01.jpg"}, project_root=str(root),
+                     cloud=boom)["state"] == "on_disk"
+
+
+def test_resolve_files_passes_cloud_and_counts_it(tmp_path):
+    root = _project(tmp_path)
+    g = Graph("c")
+    api.add_resource(g, name="D.01", kind="image", files=[{"path": "/DosCo/D.01.jpg"}], resource_id="d1")
+    res = api.resolve_files(g, project_root=str(root), cloud=lambda p: True)
+    assert {r["state"] for r in res} == {"in_cloud"}
+    assert L.summary(res)["in_cloud"] == len(res)
+
+
+def test_asset_list_says_the_versions_in_the_cloud(tmp_path):
+    g = Graph("lista")
+    v0, _ = _model(g, "col", "0", tris=60_000)
+    states = {v0["version_id"]: "in_cloud", "col": "in_cloud"}
+    measured = []
+    out = AL.asset_list(g, states=states, measure=lambda e: measured.append(e) or None)
+    a = out["assets"][0]
+    lod0 = next(v for v in a["versions"] if v["id"] == v0["version_id"])
+    assert lod0["in_cloud"] and lod0["state"] == "in_cloud" and not lod0["measured"]
+    assert lod0["triangles"] == 60_000           # the graph's estimate
+    assert v0["version_id"] in a["audit"]["files_in_cloud"]
+    assert out["counts"]["in_cloud"] >= 1 and "nel cloud" in out["say_it"]
+    assert a["targets"]["arch"]["state"] == "ok" and "cloud" in a["targets"]["arch"]["why"]
+
+
+def test_list_versions_does_not_measure_a_version_in_the_cloud(tmp_path):
+    from s3dgraphy.resources import use_profiles as UP
+    from tests.test_consolida_2 import _glb, _png
+    v = tmp_path / "versions"
+    v.mkdir()
+    _glb(v / "Col@lod1-web.glb", [_png(512)])
+    _glb(v / "Col@lod2-mobile.glb", [_png(256)])
+    rows = {r["name"]: r for r in UP.list_versions(str(v), cloud=lambda p: "lod2" in p)}
+    assert rows["Col@lod2-mobile.glb"]["in_cloud"] and rows["Col@lod2-mobile.glb"]["triangles"] is None
+    assert not rows["Col@lod1-web.glb"].get("in_cloud") and rows["Col@lod1-web.glb"]["triangles"] == 1