s3dgraphy 1.6.0.dev55__tar.gz → 1.6.0.dev57__tar.gz

{s3dgraphy-1.6.0.dev55/src/s3dgraphy.egg-info → s3dgraphy-1.6.0.dev57}/PKG-INFO

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

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

{s3dgraphy-1.6.0.dev55 → s3dgraphy-1.6.0.dev57}/src/s3dgraphy/JSON_config/em_visual_rules.json

@@ -1,6 +1,6 @@
 {
   "formal_language": "EM",
-  "version": "1.6.34",
+  "version": "1.6.36",
   "_note_material_vs_qualia_color": [
     "DUE COSE DIVERSE CHE SI CHIAMANO ENTRAMBE color. Non confonderle: e gia successo.",
     "1) QUI, in node_styles.<tipo>.style.material.rgba_color — il COLORE DEL MATERIALE BLENDER del proxy 3D, in float LINEARI. UNA sola chiave: `rgba_color`. Fino a S8 il file ne usava due (`color` sui 13 tipi stratigrafici, `rgba_color` sugli altri) e get_material_color() ne leggeva una sola, restituendo None per 21 tipi su 38; ora sono unificate e la vecchia `color` e letta solo come tolleranza verso file scritti prima. Un tipo che non diventa mai una mesh NON ha material affatto (i contenitori di gruppo, e da S7 i dieci nodi che rendono per icona): per loro get_material_color() torna None, ed e corretto.",
@@ -9,6 +9,8 @@
     "In breve: qui si decide di che colore DISEGNARE una US; li si registra di che colore ERA."
   ],
   "_changelog": {
+    "1.6.36": "THE RM IS BOUND TO THE EPOCH ONLY DIRECTLY (MICRO lo spazio 3D 2, Parte 0, E.D. 16 Oct 2026). threed_instances.representation_model loses `via_property`: an epoch reaches its model only by a direct has_representation_model, the one form the connections datamodel admits (a property is not a source of has_representation_model) and the only one in the data (the 99 RMs of Templu Mare v2). «×N» counts the epochs bound directly.",
+    "1.6.35": "RM AND PROXY AMONG THE COMPUTED INSTANCES (MICRO lo spazio 3D, E.D. 11 Oct 2026). New block threed_instances: the proxy of a unit (geometry property → has_semantic_shape → SemanticShape) is drawn in the paradata group of the property, beside it; a representation model is drawn in the paradata group of each epoch that has it (has_representation_model, directly or through an epoch property), with the number of its epochs («×N»). A view: nothing in em.json or RDF. Read by s3dgraphy.paradata_view.threed_instances and units_without_3d.",
     "1.6.34": "THE AUTHOR AS AN INSTANCE (MICRO le entità spaziotemporali, decided by E.D. 10 Oct 2026: documents, authors and units are spatiotemporal entities, and an author «si istanzia come avviene con i documenti»). paradata_instances gains `authorship`: the author of a reader of the group (the extractor, or the combiner and the extractors it combines) reached by has_author, when the author is not itself a member of the group, is drawn inside the group as an INSTANCE of kind `author`, with the badge of the epoch where the author begins (has_first_epoch). Still a view: nothing is written in em.json or RDF. s3dgraphy.paradata_view.view_instances reads it.",
     "1.6.32": "THE GLYPHS OF THE 3D OBJECTS (MICRO «grafo reattivo», G9, 9 Oct 2026; drawings approved by E.D. on 6 Oct, APPROVATE.md). representation_model, representation_model_doc (the checkered picture seen three-quarters, with its frame's depth and a shadow on the ground: an image PLACED in 3D space) and representation_model_sf replace the three identical Font Awesome cubes of src/2D/ and join `2d_render_glyph_types.types`; proxy, tileset, container (the RM container, RepresentationModelNodeGroup) and the four versions version:gltf / version:mesh / version:tiles / version:scene are new files, resolved from the node's DATA by the new table `2d_render_glyph_types.data_glyphs` (keyed like dtc:<kind>; its rule is written in its _comment, measured on Templu Mare v2). All ten in the DTC frame (circle r 41.14, viewBox 87.12) with the 2×2 checker of the EMtools icons: the checker colours are `accent`, never recoloured; black `ink`, white `paper`, the grey of the picture's frame `ground`, the shadow `halo`. NEW in the layer format: `frame: true` marks the layers of the frame circle (its `paper` fill and its `ink` stroke), and the entry's `frameless_box` is the box of everything else — below 24 px a consumer may skip the frame and fit that box instead (docs/drawing-a-glyph.md §5). Additive: no existing glyph changed.",
     "1.6.31": "THE CHOICES OF DEV29, CONFIRMED (E.D., 2 Oct 2026, on the dev29 report, D5). dtc_kinds.process.texturing is projection AND baking of the photographs onto the mesh, one act, one kind; the baking of levels of detail in Blender stays lod_generation, an act of its own. The «until E.D. says otherwise» of 1.6.30 is gone from the description. Text only: no kind, glyph or label changed.",
@@ -6239,6 +6241,29 @@
       }
     }
   },
+  "threed_instances": {
+    "_comment": "1.6.35 (MICRO lo spazio 3D, E.D. 11 Oct 2026: «nel grafo, la presenza del 3D visibile accanto alle unità e alle epoche»). The representation models and the proxies join the computed instances, and like them they are a VIEW: nothing is written in em.json or RDF. PROXY: the property of type `geometry` of a unit reaches by `has_semantic_shape` the SemanticShape (the proxy, its glb a `proxy_model` resource by `has_linked_resource`); the view draws the shape in the paradata group of the property — its own `is_in_paradata_nodegroup`, else the group of its original owner (`has_paradata_nodegroup`) — BESIDE the property. RM: an epoch reaches its model by a direct `has_representation_model` (1.6.36: the road through an epoch property is gone, the connections datamodel does not admit it); the view draws the model in the epoch's paradata group, and when the same model is in N epochs every instance carries N («×N»). With no group, `place` is the owner itself (the unit, the epoch). The reference implementation is s3dgraphy.paradata_view.threed_instances; units_without_3d answers which units have a proxy, a geometry without payload, or none.",
+    "proxy": {
+      "kind": "proxy",
+      "owner_edge": "has_property",
+      "property_type": "geometry",
+      "shape_edge": "has_semantic_shape",
+      "file_edge": "has_linked_resource",
+      "file_types": ["proxy_model"],
+      "membership": "is_in_paradata_nodegroup",
+      "group_edge": "has_paradata_nodegroup",
+      "beside": "property"
+    },
+    "representation_model": {
+      "kind": "rm",
+      "holders": ["EpochNode"],
+      "edge": "has_representation_model",
+      "masters": ["RepresentationModelNode", "RepresentationModelDocNode", "RepresentationModelSpecialFindNode"],
+      "group_edge": "has_paradata_nodegroup",
+      "count_word": "×{n}"
+    },
+    "id": "{master}##{place}"
+  },
   "dtc_kinds": {
     "_comment": "DATA-DRIVEN, EXPANDABLE per-kind vocabulary for the DTC substrate profile (ECHOES). Mirrors the Master-Document axis vocabularies above (document_roles/content_natures): the three base kinds (input/process/output) each list specific kinds seeded from the 2017 DTC palette. Adding a new kind (e.g. audio, spectroscopy) is a JSON entry here (+ a glyph) — NOT a code change; the DTC node classes validate against these keys via s3dgraphy.utils.get_dtc_kinds(). `glyph` names the 2017 DTC SVG (wired in the later glyph/visual-manager slice; recorded here as data only).",
     "input": {

{s3dgraphy-1.6.0.dev55 → s3dgraphy-1.6.0.dev57}/src/s3dgraphy/__init__.py

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

{s3dgraphy-1.6.0.dev55 → s3dgraphy-1.6.0.dev57}/src/s3dgraphy/api.py

@@ -342,6 +342,24 @@ def view_instances(graph: Graph, group_id: str) -> List[Dict[str, Any]]:
     return _view(graph, group_id)
 
 
+def threed_instances(graph: Graph) -> List[Dict[str, Any]]:
+    """The proxies and the representation models as the view draws them
+    (em_visual_rules 1.6.35, ``threed_instances``): the proxy of a unit in the
+    paradata group of its geometry property, beside it; a model in the paradata
+    group of each epoch that has it, with the number of its epochs. Computed,
+    never stored; see :func:`s3dgraphy.paradata_view.threed_instances`."""
+    from .paradata_view import threed_instances as _view
+    return _view(graph)
+
+
+def units_without_3d(graph: Graph) -> Dict[str, List[str]]:
+    """``{with, empty, none, without}``: the units with a proxy, with an empty
+    geometry property, with none, and the last two together — see
+    :func:`s3dgraphy.paradata_view.units_without_3d`."""
+    from .paradata_view import units_without_3d as _units
+    return _units(graph)
+
+
 def dependents_of(graph: Graph, node_id: str) -> List[Dict[str, Any]]:
     """Who leans on a unit, a property or a document, in cascade: ``[{id,
     name, node_type, kind, via, depth, owner, owner_name}]`` — what an

{s3dgraphy-1.6.0.dev55 → s3dgraphy-1.6.0.dev57}/src/s3dgraphy/paradata_view.py

@@ -241,3 +241,224 @@ def all_view_instances(graph) -> Dict[str, List[Dict[str, Any]]]:
             if recs:
                 out[n.node_id] = recs
     return out
+
+
+# ── 1.6.35 · the 3D among the computed instances ─────────────────────────────
+#
+# MICRO lo spazio 3D (E.D., 11 Oct 2026): «nel grafo, la presenza del 3D visibile
+# accanto alle unità e alle epoche». The proxy of a unit and the representation
+# model of an epoch are drawn as instances, like a document read from outside:
+# still a view, nothing written. The rule is `em_visual_rules.json` →
+# `threed_instances`.
+
+
+@lru_cache(maxsize=1)
+def threed_rule() -> Dict[str, Any]:
+    """The ``threed_instances`` block of ``em_visual_rules.json``."""
+    from .nodes.base_node import load_json_mapping
+    rules = load_json_mapping("em_visual_rules.json") or {}
+    return dict(rules.get("threed_instances") or {})
+
+
+def threed_instance_id(master_id: str, place_id: str) -> str:
+    """The id every client gives the 3D instance of ``master_id`` drawn in
+    ``place_id`` (a paradata group, else the owner itself)."""
+    pattern = threed_rule().get("id") or "{master}##{place}"
+    return pattern.format(master=master_id, place=place_id)
+
+
+def _out(graph, node_id: str, edge_type: str) -> List[str]:
+    return [e.edge_target for e in graph.edges
+            if e.edge_source == node_id and e.edge_type == edge_type and _live(e)]
+
+
+def _inn(graph, node_id: str, edge_type: str) -> List[str]:
+    return [e.edge_source for e in graph.edges
+            if e.edge_target == node_id and e.edge_type == edge_type and _live(e)]
+
+
+def _property_type(node) -> str:
+    data = getattr(node, "data", None) or {}
+    return str(getattr(node, "property_type", None) or data.get("property_type") or "")
+
+
+def _proxy_payload(graph, shape, spec: Dict[str, Any]) -> Dict[str, Any]:
+    """What a shape carries: its ``proxy_model`` resources, its hulls and spheres."""
+    types = set(spec.get("file_types") or ["proxy_model"])
+    files = []
+    for rid in _out(graph, shape.node_id, spec.get("file_edge") or "has_linked_resource"):
+        res = graph.find_node_by_id(rid)
+        data = getattr(res, "data", None) or {}
+        if res is None or _removed(res) or getattr(res, "node_type", None) != "resource":
+            continue
+        if types & {data.get("url_type"), data.get("resource_type")}:
+            files.append(rid)
+    data = getattr(shape, "data", None) or {}
+    hulls = bool(data.get("convexshapes") or getattr(shape, "convexshapes", None))
+    spheres = bool(data.get("spheres") or getattr(shape, "spheres", None))
+    return {"files": files, "hulls": hulls or spheres}
+
+
+def _place(graph, owner_id: str, prop_id: Optional[str], spec: Dict[str, Any]) -> Optional[str]:
+    """The paradata group a 3D instance is drawn in: the property's own group,
+    else the group of the owner (``has_paradata_nodegroup``)."""
+    if prop_id:
+        for g in _out(graph, prop_id, spec.get("membership") or "is_in_paradata_nodegroup"):
+            node = graph.find_node_by_id(g)
+            if node is not None and not _removed(node):
+                return g
+    for g in _out(graph, owner_id, spec.get("group_edge") or "has_paradata_nodegroup"):
+        node = graph.find_node_by_id(g)
+        if node is not None and not _removed(node):
+            return g
+    return None
+
+
+def _units(graph):
+    from .nodes.stratigraphic_node import ContinuityNode, StratigraphicNode
+    return [n for n in graph.nodes if isinstance(n, StratigraphicNode)
+            and not isinstance(n, ContinuityNode) and not _removed(n)]
+
+
+def proxy_instances(graph) -> List[Dict[str, Any]]:
+    """The proxies of the units, as instances::
+
+        {id, kind: "proxy", master, node_type, name, owner, owner_kind: "unit",
+         owner_name, beside, group, place, files, empty, removed}
+
+    ``master`` the SemanticShape; ``beside`` the geometry property it hangs
+    from; ``group`` the paradata group it is drawn in (None when the unit has
+    none: ``place`` is then the unit); ``files`` its ``proxy_model``
+    resources; ``empty`` when the shape carries neither a file nor hulls.
+    """
+    from .ownership import original_owner
+    spec = dict(threed_rule().get("proxy") or {})
+    owner_edge = spec.get("owner_edge") or "has_property"
+    ptype = spec.get("property_type") or "geometry"
+    shape_edge = spec.get("shape_edge") or "has_semantic_shape"
+    out: List[Dict[str, Any]] = []
+    seen = set()
+    for unit in _units(graph):
+        for pid in _out(graph, unit.node_id, owner_edge):
+            prop = graph.find_node_by_id(pid)
+            if prop is None or _removed(prop) or _property_type(prop) != ptype:
+                continue
+            # a property inherited by a second unit is drawn once, by its owner
+            owner = original_owner(graph, pid) or unit.node_id
+            if owner != unit.node_id:
+                continue
+            for sid in _out(graph, pid, shape_edge):
+                shape = graph.find_node_by_id(sid)
+                if shape is None or (pid, sid) in seen:
+                    continue
+                seen.add((pid, sid))
+                payload = _proxy_payload(graph, shape, spec)
+                group = _place(graph, unit.node_id, pid, spec)
+                place = group or unit.node_id
+                out.append({
+                    "id": threed_instance_id(sid, place), "kind": spec.get("kind") or "proxy",
+                    "master": sid, "node_type": getattr(shape, "node_type", None),
+                    "name": getattr(shape, "name", sid),
+                    "owner": unit.node_id, "owner_kind": "unit",
+                    "owner_name": getattr(unit, "name", unit.node_id),
+                    "beside": pid, "group": group, "place": place,
+                    "files": payload["files"],
+                    "empty": not payload["files"] and not payload["hulls"],
+                    "removed": _removed(shape)})
+    return out
+
+
+def rm_instances(graph) -> List[Dict[str, Any]]:
+    """The representation models of the epochs, as instances::
+
+        {id, kind: "rm", master, node_type, name, owner, owner_kind: "epoch",
+         owner_name, group, place, epochs, count, count_label, removed}
+
+    One per (model, epoch), for a direct ``has_representation_model`` only
+    (1.6.36: the connections datamodel admits no other form); ``epochs`` every
+    epoch the model is in, ``count`` how many, ``count_label`` the rule's word
+    («×3») when there are more than one.
+    """
+    spec = dict(threed_rule().get("representation_model") or {})
+    holders = spec.get("holders") or ["EpochNode"]
+    edge = spec.get("edge") or "has_representation_model"
+    masters = spec.get("masters") or ["RepresentationModelNode", "RepresentationModelDocNode",
+                                      "RepresentationModelSpecialFindNode"]
+    word = spec.get("count_word") or "×{n}"
+    links: Dict[str, List[Dict[str, Any]]] = {}
+    order: List[str] = []
+    for holder in graph.nodes:
+        if _removed(holder) or _class_of(holder, holders) is None:
+            continue
+        for rm_id in _out(graph, holder.node_id, edge):
+            rm = graph.find_node_by_id(rm_id)
+            if rm is None or _class_of(rm, masters) is None:
+                continue
+            mine = links.setdefault(rm_id, [])
+            if any(x["owner"] == holder.node_id for x in mine):
+                continue
+            if rm_id not in order:
+                order.append(rm_id)
+            mine.append({"owner": holder.node_id})
+    out: List[Dict[str, Any]] = []
+    for rm_id in order:
+        rm = graph.find_node_by_id(rm_id)
+        epochs = [x["owner"] for x in links[rm_id]]
+        n = len(epochs)
+        for x in links[rm_id]:
+            epoch = graph.find_node_by_id(x["owner"])
+            group = _place(graph, x["owner"], None, spec)
+            place = group or x["owner"]
+            out.append({
+                "id": threed_instance_id(rm_id, place), "kind": spec.get("kind") or "rm",
+                "master": rm_id, "node_type": getattr(rm, "node_type", None),
+                "name": getattr(rm, "name", rm_id),
+                "owner": x["owner"], "owner_kind": "epoch",
+                "owner_name": getattr(epoch, "name", x["owner"]),
+                "group": group, "place": place,
+                "epochs": list(epochs), "count": n,
+                "count_label": word.format(n=n) if n > 1 else None,
+                "removed": _removed(rm)})
+    return out
+
+
+def threed_instances(graph) -> List[Dict[str, Any]]:
+    """The proxies and the representation models, as the view draws them:
+    :func:`proxy_instances` then :func:`rm_instances`. Pure."""
+    return proxy_instances(graph) + rm_instances(graph)
+
+
+def units_without_3d(graph) -> Dict[str, List[str]]:
+    """Which units have a 3D proxy, and which do not::
+
+        {"with": [...], "empty": [...], "none": [...], "without": [...]}
+
+    ``with`` a geometry property whose shape carries a file or hulls;
+    ``empty`` a geometry property and nothing in it (no shape, or a shape
+    with neither file nor hulls); ``none`` no geometry property at all;
+    ``without`` = ``empty`` + ``none``, the units a proxy can be given to.
+    Continuity nodes are not units to model.
+    """
+    spec = dict(threed_rule().get("proxy") or {})
+    owner_edge = spec.get("owner_edge") or "has_property"
+    ptype = spec.get("property_type") or "geometry"
+    shape_edge = spec.get("shape_edge") or "has_semantic_shape"
+    res: Dict[str, List[str]] = {"with": [], "empty": [], "none": [], "without": []}
+    for unit in _units(graph):
+        props = [graph.find_node_by_id(p) for p in _out(graph, unit.node_id, owner_edge)]
+        props = [p for p in props if p is not None and not _removed(p) and _property_type(p) == ptype]
+        if not props:
+            res["none"].append(unit.node_id)
+            continue
+        full = False
+        for p in props:
+            for sid in _out(graph, p.node_id, shape_edge):
+                shape = graph.find_node_by_id(sid)
+                if shape is None or _removed(shape):
+                    continue
+                pay = _proxy_payload(graph, shape, spec)
+                if pay["files"] or pay["hulls"]:
+                    full = True
+        res["with" if full else "empty"].append(unit.node_id)
+    res["without"] = res["empty"] + res["none"]
+    return res

{s3dgraphy-1.6.0.dev55 → s3dgraphy-1.6.0.dev57/src/s3dgraphy.egg-info}/PKG-INFO

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

@@ -551,6 +551,7 @@ tests/test_storage_rows.py
 tests/test_store_backed_geometry.py
 tests/test_stratiminer_api.py
 tests/test_study_metadata.py
+tests/test_threed_instances.py
 tests/test_tileset_resource.py
 tests/test_ttl_roundtrip.py
 tests/test_unit_definition.py

s3dgraphy-1.6.0.dev57/tests/test_threed_instances.py

@@ -0,0 +1,150 @@
+"""The 3D among the computed instances (em_visual_rules 1.6.35, MICRO lo spazio
+3D, E.D. 11 Oct 2026).
+
+The proxy of a unit is drawn in the paradata group of its geometry property,
+beside the property; a representation model in the paradata group of every epoch
+bound to it directly (1.6.36: not through an epoch property) — with the number of
+its epochs. A view: the graph is only read. ``units_without_3d`` says which units a
+proxy can be given to.
+"""
+
+import json
+import pathlib
+
+from s3dgraphy import api
+from s3dgraphy.geometry.proxy import create_geometry_proxy
+from s3dgraphy.graph import Graph
+from s3dgraphy.nodes import PropertyNode, StratigraphicUnit
+from s3dgraphy.nodes.epoch_node import EpochNode
+from s3dgraphy.nodes.group_node import ParadataNodeGroup
+from s3dgraphy.nodes.representation_node import RepresentationModelNode
+from s3dgraphy.nodes.semantic_shape_node import SemanticShapeNode
+
+
+def _templum() -> Graph:
+    g = Graph(graph_id="templum")
+    for eid, name, start in (("E1", "I a.C.", -100), ("E2", "I d.C.", 1), ("E3", "II d.C.", 101)):
+        g.add_node(EpochNode(eid, name, start, start + 99))
+        g.add_node(ParadataNodeGroup(f"PD_{eid}", f"PD_{name}"))
+        g.add_edge(f"hg_{eid}", eid, f"PD_{eid}", "has_paradata_nodegroup")
+    # US 1: a proxy with a glb, and a paradata group of its own
+    g.add_node(StratigraphicUnit("US1", name="US 1"))
+    g.add_node(ParadataNodeGroup("PD_US1", "US1_PD"))
+    g.add_edge("hg_US1", "US1", "PD_US1", "has_paradata_nodegroup")
+    create_geometry_proxy(g, "US1", {"url": "proxies/US 1.glb"})
+    # US 2: a proxy from hulls, no group
+    g.add_node(StratigraphicUnit("US2", name="US 2"))
+    create_geometry_proxy(g, "US2", {"convexshapes": [[0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1]]})
+    # US 3: a geometry property and nothing in it
+    g.add_node(StratigraphicUnit("US3", name="US 3"))
+    g.add_node(PropertyNode("P3", name="geometry", value="", property_type="geometry"))
+    g.add_edge("h3", "US3", "P3", "has_property")
+    # US 4: an empty shape
+    g.add_node(StratigraphicUnit("US4", name="US 4"))
+    g.add_node(PropertyNode("P4", name="geometry", value="S4", property_type="geometry"))
+    g.add_node(SemanticShapeNode("S4", name="US 4 geometry"))
+    g.add_edge("h4", "US4", "P4", "has_property")
+    g.add_edge("s4", "P4", "S4", "has_semantic_shape")
+    # US 5: no geometry
+    g.add_node(StratigraphicUnit("US5", name="US 5"))
+    # RM_A in three epochs, RM_B in one, all bound directly
+    g.add_node(RepresentationModelNode("RM_A", name="cella"))
+    g.add_node(RepresentationModelNode("RM_B", name="pronao"))
+    g.add_edge("r1", "E1", "RM_A", "has_representation_model")
+    g.add_edge("r2", "E2", "RM_A", "has_representation_model")
+    g.add_edge("r3", "E3", "RM_A", "has_representation_model")
+    g.add_edge("r4", "E3", "RM_B", "has_representation_model")
+    return g
+
+
+def test_the_proxy_sits_beside_its_property_in_the_unit_group():
+    g = _templum()
+    recs = {r["owner"]: r for r in api.threed_instances(g) if r["kind"] == "proxy"}
+    assert set(recs) == {"US1", "US2", "US4"}
+    us1 = recs["US1"]
+    prop = next(e.edge_target for e in g.edges
+                if e.edge_source == "US1" and e.edge_type == "has_property")
+    assert us1["beside"] == prop and us1["group"] == "PD_US1"
+    assert us1["id"] == f"{us1['master']}##PD_US1" and len(us1["files"]) == 1
+    assert not us1["empty"]
+    # no group: the place is the unit itself
+    assert recs["US2"]["group"] is None and recs["US2"]["place"] == "US2"
+    assert not recs["US2"]["empty"] and recs["US2"]["files"] == []
+    assert recs["US4"]["empty"]
+
+
+def test_a_property_in_a_group_of_its_own_wins():
+    g = _templum()
+    g.add_node(ParadataNodeGroup("PD_X", "X_PD"))
+    prop = next(e.edge_target for e in g.edges
+                if e.edge_source == "US2" and e.edge_type == "has_property")
+    g.add_edge("mx", prop, "PD_X", "is_in_paradata_nodegroup")
+    (us2,) = [r for r in api.threed_instances(g) if r["owner"] == "US2"]
+    assert us2["group"] == "PD_X"
+
+
+def test_a_model_in_three_epochs_says_x3_in_each():
+    g = _templum()
+    rms = [r for r in api.threed_instances(g) if r["kind"] == "rm"]
+    a = {r["owner"]: r for r in rms if r["master"] == "RM_A"}
+    assert set(a) == {"E1", "E2", "E3"}
+    assert {r["count"] for r in a.values()} == {3}
+    assert {r["count_label"] for r in a.values()} == {"×3"}
+    assert a["E1"]["group"] == "PD_E1" and a["E1"]["id"] == "RM_A##PD_E1"
+    (b,) = [r for r in rms if r["master"] == "RM_B"]
+    assert b["count"] == 1 and b["count_label"] is None and b["owner"] == "E3"
+
+
+def test_a_model_through_an_epoch_property_is_not_an_instance():
+    # 1.6.36: the connections datamodel does not let a property be the source
+    # of has_representation_model; an em.json written by hand with that form
+    # gives no instance (and no «×N»)
+    g = Graph(graph_id="by-hand")
+    g.add_node(EpochNode("E1", "I d.C.", 1, 100))
+    g.add_node(RepresentationModelNode("RM_C", name="podio"))
+    g.add_node(PropertyNode("PE1", name="modello", value="RM_C"))
+    g.add_edge("hpe1", "E1", "PE1", "has_property")
+    g.add_edge("rc", "PE1", "RM_C", "has_representation_model")
+    g.find_edge_by_id("rc").edge_type = "has_representation_model"
+    assert [r for r in api.threed_instances(g) if r["kind"] == "rm"] == []
+
+
+def test_units_without_3d():
+    g = _templum()
+    u = api.units_without_3d(g)
+    assert u["with"] == ["US1", "US2"]
+    assert u["empty"] == ["US3", "US4"]
+    assert u["none"] == ["US5"]
+    assert u["without"] == ["US3", "US4", "US5"]
+
+
+def test_a_view_writes_nothing():
+    g = _templum()
+    before = (len(g.nodes), len(g.edges))
+    api.threed_instances(g)
+    api.units_without_3d(g)
+    assert (len(g.nodes), len(g.edges)) == before
+
+
+def test_a_removed_shape_and_link_are_not_drawn():
+    g = _templum()
+    api.remove_keeping_trace(g, "RM_B", at="2026-10-16T10:00:00Z")
+    (b,) = [r for r in api.threed_instances(g) if r["master"] == "RM_B"]
+    assert b["removed"]
+    edge = g.find_edge_by_id("r1")
+    edge.attributes = dict(getattr(edge, "attributes", None) or {},
+                           removed={"ts": "2026-10-16T10:00:00Z", "by": "dev"})
+    a = [r for r in api.threed_instances(g) if r["master"] == "RM_A"]
+    assert {r["owner"] for r in a} == {"E2", "E3"} and {r["count"] for r in a} == {2}
+
+
+def test_the_rule_is_in_the_visual_rules():
+    from s3dgraphy.paradata_view import threed_rule
+    raw = json.loads((pathlib.Path(api.__file__).parent / "JSON_config" /
+                      "em_visual_rules.json").read_text("utf-8"))
+    block = raw["threed_instances"]
+    assert block == threed_rule()
+    assert block["id"] == "{master}##{place}"
+    assert block["proxy"]["shape_edge"] == "has_semantic_shape"
+    assert block["representation_model"]["count_word"] == "×{n}"
+    assert "via_property" not in block["representation_model"]