diff --git a/swh/dataset/graph.py b/swh/dataset/graph.py
index 52165fe..486aec8 100644
--- a/swh/dataset/graph.py
+++ b/swh/dataset/graph.py
@@ -1,241 +1,241 @@
 # Copyright (C) 2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import contextlib
 import functools
 import os
 import os.path
 import pathlib
 import shlex
 import subprocess
 import tempfile
 import uuid
 
 from swh.dataset.exporter import ParallelExporter
 from swh.dataset.utils import SQLiteSet, ZSTFile
 from swh.model.identifiers import origin_identifier, swhid
 from swh.storage.fixer import fix_objects
 
 
 def process_messages(messages, config, node_writer, edge_writer, node_set):
     """
     Args:
         messages: A sequence of messages to process
         config: The exporter configuration
         node_writer: A file-like object where to write nodes
         edge_writer: A file-like object where to write edges
     """
 
     def write_node(node):
         node_type, node_id = node
         if node_id is None:
             return
         node_swhid = swhid(object_type=node_type, object_id=node_id)
         node_writer.write("{}\n".format(node_swhid))
 
     def write_edge(src, dst):
         src_type, src_id = src
         dst_type, dst_id = dst
         if src_id is None or dst_id is None:
             return
         src_swhid = swhid(object_type=src_type, object_id=src_id)
         dst_swhid = swhid(object_type=dst_type, object_id=dst_id)
         edge_writer.write("{} {}\n".format(src_swhid, dst_swhid))
 
     messages = {k: fix_objects(k, v) for k, v in messages.items()}
 
-    for visit in messages.get("origin_visit", []):
-        origin_id = origin_identifier({"url": visit["origin"]})
-        visit_id = visit["visit"]
+    for visit_status in messages.get("origin_visit_status", []):
+        origin_id = origin_identifier({"url": visit_status["origin"]})
+        visit_id = visit_status["visit"]
         if not node_set.add("{}:{}".format(origin_id, visit_id).encode()):
             continue
         write_node(("origin", origin_id))
-        write_edge(("origin", origin_id), ("snapshot", visit["snapshot"]))
+        write_edge(("origin", origin_id), ("snapshot", visit_status["snapshot"]))
 
     for snapshot in messages.get("snapshot", []):
         if not node_set.add(snapshot["id"]):
             continue
         write_node(("snapshot", snapshot["id"]))
         for branch_name, branch in snapshot["branches"].items():
             while branch and branch.get("target_type") == "alias":
                 branch_name = branch["target"]
                 branch = snapshot["branches"][branch_name]
             if branch is None or not branch_name:
                 continue
             # Heuristic to filter out pull requests in snapshots: remove all
             # branches that start with refs/ but do not start with refs/heads or
             # refs/tags.
             if config.get("remove_pull_requests") and (
                 branch_name.startswith(b"refs/")
                 and not (
                     branch_name.startswith(b"refs/heads")
                     or branch_name.startswith(b"refs/tags")
                 )
             ):
                 continue
             write_edge(
                 ("snapshot", snapshot["id"]), (branch["target_type"], branch["target"])
             )
 
     for release in messages.get("release", []):
         if not node_set.add(release["id"]):
             continue
         write_node(("release", release["id"]))
         write_edge(
             ("release", release["id"]), (release["target_type"], release["target"])
         )
 
     for revision in messages.get("revision", []):
         if not node_set.add(revision["id"]):
             continue
         write_node(("revision", revision["id"]))
         write_edge(("revision", revision["id"]), ("directory", revision["directory"]))
         for parent in revision["parents"]:
             write_edge(("revision", revision["id"]), ("revision", parent))
 
     for directory in messages.get("directory", []):
         if not node_set.add(directory["id"]):
             continue
         write_node(("directory", directory["id"]))
         for entry in directory["entries"]:
             entry_type_mapping = {
                 "file": "content",
                 "dir": "directory",
                 "rev": "revision",
             }
             write_edge(
                 ("directory", directory["id"]),
                 (entry_type_mapping[entry["type"]], entry["target"]),
             )
 
     for content in messages.get("content", []):
         if not node_set.add(content["sha1_git"]):
             continue
         write_node(("content", content["sha1_git"]))
 
 
 class GraphEdgeExporter(ParallelExporter):
     """
     Implementation of ParallelExporter which writes all the graph edges
     of a specific type in a Zstandard-compressed CSV file.
 
     Each row of the CSV is in the format: `<SRC SWHID> <DST SWHID>
     """
 
     def export_worker(self, export_path, **kwargs):
         dataset_path = pathlib.Path(export_path)
         dataset_path.mkdir(exist_ok=True, parents=True)
         unique_id = str(uuid.uuid4())
         nodes_file = dataset_path / ("graph-{}.nodes.csv.zst".format(unique_id))
         edges_file = dataset_path / ("graph-{}.edges.csv.zst".format(unique_id))
         node_set_file = dataset_path / (".set-nodes-{}.sqlite3".format(unique_id))
 
         with contextlib.ExitStack() as stack:
             node_writer = stack.enter_context(ZSTFile(nodes_file, "w"))
             edge_writer = stack.enter_context(ZSTFile(edges_file, "w"))
             node_set = stack.enter_context(SQLiteSet(node_set_file))
 
             process_fn = functools.partial(
                 process_messages,
                 config=self.config,
                 node_writer=node_writer,
                 edge_writer=edge_writer,
                 node_set=node_set,
             )
             self.process(process_fn, **kwargs)
 
 
 def export_edges(config, export_path, export_id, processes):
     """Run the edge exporter for each edge type."""
     object_types = [
-        "origin_visit",
+        "origin_visit_status",
         "snapshot",
         "release",
         "revision",
         "directory",
         "content",
     ]
     for obj_type in object_types:
         print("{} edges:".format(obj_type))
         exporter = GraphEdgeExporter(config, export_id, obj_type, processes)
         exporter.run(os.path.join(export_path, obj_type))
 
 
 def sort_graph_nodes(export_path, config):
     """
     Generate the node list from the edges files.
 
     We cannot solely rely on the object IDs that are read in the journal,
     as some nodes that are referred to as destinations in the edge file
     might not be present in the archive (e.g a rev_entry referring to a
     revision that we do not have crawled yet).
 
     The most efficient way of getting all the nodes that are mentioned in
     the edges file is therefore to use sort(1) on the gigantic edge files
     to get all the unique node IDs, while using the disk as a temporary
     buffer.
 
     This pipeline does, in order:
 
      - concatenate and write all the compressed edges files in
        graph.edges.csv.zst (using the fact that ZST compression is an additive
        function) ;
      - deflate the edges ;
      - count the number of edges and write it in graph.edges.count.txt ;
      - count the number of occurrences of each edge type and write them
        in graph.edges.stats.txt ;
      - concatenate all the (deflated) nodes from the export with the
        destination edges, and sort the output to get the list of unique graph
        nodes ;
      - count the number of unique graph nodes and write it in
        graph.nodes.count.txt ;
      - count the number of occurrences of each node type and write them
        in graph.nodes.stats.txt ;
      - compress and write the resulting nodes in graph.nodes.csv.zst.
     """
 
     # Use awk as a replacement of `sort | uniq -c` to avoid buffering everything
     # in memory
     counter_command = "awk '{ t[$0]++ } END { for (i in t) print i,t[i] }'"
 
     # Use bytes for the sorting algorithm (faster than being locale-specific)
     env = {
         **os.environ.copy(),
         "LC_ALL": "C",
         "LC_COLLATE": "C",
         "LANG": "C",
     }
     sort_buffer_size = config.get("sort_buffer_size", "4G")
     disk_buffer_dir = config.get("disk_buffer_dir", export_path)
     with tempfile.TemporaryDirectory(
         prefix=".graph_node_sort_", dir=disk_buffer_dir
     ) as buffer_path:
         subprocess.run(
             [
                 "bash",
                 "-c",
                 (
                     "pv {export_path}/*/*.edges.csv.zst | "
                     "tee {export_path}/graph.edges.csv.zst |"
                     "zstdcat |"
                     "tee >( wc -l > {export_path}/graph.edges.count.txt ) |"
                     "tee >( cut -d: -f3,6 | {counter_command} | sort "
                     "           > {export_path}/graph.edges.stats.txt ) |"
                     "cut -d' ' -f2 | "
                     "cat - <( zstdcat {export_path}/*/*.nodes.csv.zst ) | "
                     "sort -u -S{sort_buffer_size} -T{buffer_path} | "
                     "tee >( wc -l > {export_path}/graph.nodes.count.txt ) |"
                     "tee >( cut -d: -f3 | {counter_command} | sort "
                     "           > {export_path}/graph.nodes.stats.txt ) |"
                     "zstdmt > {export_path}/graph.nodes.csv.zst"
                 ).format(
                     export_path=shlex.quote(str(export_path)),
                     buffer_path=shlex.quote(str(buffer_path)),
                     sort_buffer_size=shlex.quote(sort_buffer_size),
                     counter_command=counter_command,
                 ),
             ],
             env=env,
         )
diff --git a/swh/dataset/test/test_graph.py b/swh/dataset/test/test_graph.py
index 55b7bdf..94e6ca0 100644
--- a/swh/dataset/test/test_graph.py
+++ b/swh/dataset/test/test_graph.py
@@ -1,516 +1,515 @@
 # Copyright (C) 2020  The Software Heritage developers
 # See the AUTHORS file at the top-level directory of this distribution
 # License: GNU General Public License version 3, or any later version
 # See top-level LICENSE file for more information
 
 import collections
 import hashlib
 from typing import Tuple
 from unittest.mock import Mock, call
 
 import pytest
 
 from swh.dataset.graph import process_messages, sort_graph_nodes
 from swh.dataset.utils import ZSTFile
 from swh.model.hashutil import MultiHash, hash_to_bytes
 
 DATE = {
     "timestamp": {"seconds": 1234567891, "microseconds": 0},
     "offset": 120,
     "negative_utc": False,
 }
 
 TEST_CONTENT = {
     **MultiHash.from_data(b"foo").digest(),
     "length": 3,
     "status": "visible",
 }
 
 TEST_REVISION = {
     "id": hash_to_bytes("7026b7c1a2af56521e951c01ed20f255fa054238"),
     "message": b"hello",
     "date": DATE,
     "committer": {"fullname": b"foo", "name": b"foo", "email": b""},
     "author": {"fullname": b"foo", "name": b"foo", "email": b""},
     "committer_date": DATE,
     "type": "git",
     "directory": b"\x01" * 20,
     "synthetic": False,
     "metadata": None,
     "parents": [],
 }
 
 TEST_RELEASE = {
     "id": hash_to_bytes("d81cc0710eb6cf9efd5b920a8453e1e07157b6cd"),
     "name": b"v0.0.1",
     "date": {
         "timestamp": {"seconds": 1234567890, "microseconds": 0,},
         "offset": 120,
         "negative_utc": False,
     },
     "author": {"author": {"fullname": b"foo", "name": b"foo", "email": b""}},
     "target_type": "revision",
     "target": b"\x04" * 20,
     "message": b"foo",
     "synthetic": False,
 }
 
 TEST_ORIGIN = {"url": "https://somewhere.org/den/fox"}
 TEST_ORIGIN_2 = {"url": "https://somewhere.org/den/fox/2"}
 
-TEST_ORIGIN_VISIT = {
+TEST_ORIGIN_VISIT_STATUS = {
     "origin": TEST_ORIGIN["url"],
     "visit": 1,
     "date": "2013-05-07 04:20:39.369271+00:00",
     "snapshot": None,  # TODO
     "status": "ongoing",  # TODO
     "metadata": {"foo": "bar"},
-    "type": "git",
 }
 
 
 class FakeDiskSet(set):
     """
     A set with an add() method that returns whether the item has been added
     or was already there. Used to replace SQLiteSet in unittests.
     """
 
     def add(self, v):
         assert isinstance(v, bytes)
         r = True
         if v in self:
             r = False
         super().add(v)
         return r
 
 
 @pytest.fixture
 def exporter():
     def wrapped(messages, config=None) -> Tuple[Mock, Mock]:
         if config is None:
             config = {}
         node_writer = Mock()
         edge_writer = Mock()
         node_set = FakeDiskSet()
         process_messages(
             messages,
             config=config,
             node_writer=node_writer,
             edge_writer=edge_writer,
             node_set=node_set,
         )
         return node_writer.write, edge_writer.write
 
     return wrapped
 
 
 def binhash(s):
     return hashlib.sha1(s.encode()).digest()
 
 
 def hexhash(s):
     return hashlib.sha1(s.encode()).hexdigest()
 
 
-def test_export_origin_visits(exporter):
+def test_export_origin_visit_status(exporter):
     node_writer, edge_writer = exporter(
         {
-            "origin_visit": [
+            "origin_visit_status": [
                 {
-                    **TEST_ORIGIN_VISIT,
-                    "origin": {"url": "ori1"},
+                    **TEST_ORIGIN_VISIT_STATUS,
+                    "origin": "ori1",
                     "snapshot": binhash("snp1"),
                 },
                 {
-                    **TEST_ORIGIN_VISIT,
-                    "origin": {"url": "ori2"},
+                    **TEST_ORIGIN_VISIT_STATUS,
+                    "origin": "ori2",
                     "snapshot": binhash("snp2"),
                 },
             ]
         }
     )
     assert node_writer.mock_calls == [
         call(f"swh:1:ori:{hexhash('ori1')}\n"),
         call(f"swh:1:ori:{hexhash('ori2')}\n"),
     ]
     assert edge_writer.mock_calls == [
         call(f"swh:1:ori:{hexhash('ori1')} swh:1:snp:{hexhash('snp1')}\n"),
         call(f"swh:1:ori:{hexhash('ori2')} swh:1:snp:{hexhash('snp2')}\n"),
     ]
 
 
 def test_export_snapshot_simple(exporter):
     node_writer, edge_writer = exporter(
         {
             "snapshot": [
                 {
                     "id": binhash("snp1"),
                     "branches": {
                         b"refs/heads/master": {
                             "target": binhash("rev1"),
                             "target_type": "revision",
                         },
                         b"HEAD": {"target": binhash("rev1"), "target_type": "revision"},
                     },
                 },
                 {
                     "id": binhash("snp2"),
                     "branches": {
                         b"refs/heads/master": {
                             "target": binhash("rev1"),
                             "target_type": "revision",
                         },
                         b"HEAD": {"target": binhash("rev2"), "target_type": "revision"},
                         b"bcnt": {"target": binhash("cnt1"), "target_type": "content"},
                         b"bdir": {
                             "target": binhash("dir1"),
                             "target_type": "directory",
                         },
                         b"brel": {"target": binhash("rel1"), "target_type": "release"},
                         b"bsnp": {"target": binhash("snp1"), "target_type": "snapshot"},
                     },
                 },
                 {"id": binhash("snp3"), "branches": {}},
             ]
         }
     )
     assert node_writer.mock_calls == [
         call(f"swh:1:snp:{hexhash('snp1')}\n"),
         call(f"swh:1:snp:{hexhash('snp2')}\n"),
         call(f"swh:1:snp:{hexhash('snp3')}\n"),
     ]
     assert edge_writer.mock_calls == [
         call(f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev1')}\n"),
         call(f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev1')}\n"),
         call(f"swh:1:snp:{hexhash('snp2')} swh:1:rev:{hexhash('rev1')}\n"),
         call(f"swh:1:snp:{hexhash('snp2')} swh:1:rev:{hexhash('rev2')}\n"),
         call(f"swh:1:snp:{hexhash('snp2')} swh:1:cnt:{hexhash('cnt1')}\n"),
         call(f"swh:1:snp:{hexhash('snp2')} swh:1:dir:{hexhash('dir1')}\n"),
         call(f"swh:1:snp:{hexhash('snp2')} swh:1:rel:{hexhash('rel1')}\n"),
         call(f"swh:1:snp:{hexhash('snp2')} swh:1:snp:{hexhash('snp1')}\n"),
     ]
 
 
 def test_export_snapshot_aliases(exporter):
     node_writer, edge_writer = exporter(
         {
             "snapshot": [
                 {
                     "id": binhash("snp1"),
                     "branches": {
                         b"origin_branch": {
                             "target": binhash("rev1"),
                             "target_type": "revision",
                         },
                         b"alias1": {"target": b"origin_branch", "target_type": "alias"},
                         b"alias2": {"target": b"alias1", "target_type": "alias"},
                         b"alias3": {"target": b"alias2", "target_type": "alias"},
                     },
                 },
             ]
         }
     )
     assert node_writer.mock_calls == [call(f"swh:1:snp:{hexhash('snp1')}\n")]
     assert edge_writer.mock_calls == (
         [call(f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev1')}\n")] * 4
     )
 
 
 def test_export_snapshot_no_pull_requests(exporter):
     snp = {
         "id": binhash("snp1"),
         "branches": {
             b"refs/heads/master": {
                 "target": binhash("rev1"),
                 "target_type": "revision",
             },
             b"refs/pull/42": {"target": binhash("rev2"), "target_type": "revision"},
             b"refs/merge-requests/lol": {
                 "target": binhash("rev3"),
                 "target_type": "revision",
             },
             b"refs/tags/v1.0.0": {
                 "target": binhash("rev4"),
                 "target_type": "revision",
             },
             b"refs/patch/123456abc": {
                 "target": binhash("rev5"),
                 "target_type": "revision",
             },
         },
     }
 
     node_writer, edge_writer = exporter({"snapshot": [snp]})
     assert edge_writer.mock_calls == [
         call(f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev1')}\n"),
         call(f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev2')}\n"),
         call(f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev3')}\n"),
         call(f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev4')}\n"),
         call(f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev5')}\n"),
     ]
 
     node_writer, edge_writer = exporter(
         {"snapshot": [snp]}, config={"remove_pull_requests": True}
     )
     assert edge_writer.mock_calls == [
         call(f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev1')}\n"),
         call(f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev4')}\n"),
     ]
 
 
 def test_export_releases(exporter):
     node_writer, edge_writer = exporter(
         {
             "release": [
                 {
                     **TEST_RELEASE,
                     "id": binhash("rel1"),
                     "target": binhash("rev1"),
                     "target_type": "revision",
                 },
                 {
                     **TEST_RELEASE,
                     "id": binhash("rel2"),
                     "target": binhash("rel1"),
                     "target_type": "release",
                 },
                 {
                     **TEST_RELEASE,
                     "id": binhash("rel3"),
                     "target": binhash("dir1"),
                     "target_type": "directory",
                 },
                 {
                     **TEST_RELEASE,
                     "id": binhash("rel4"),
                     "target": binhash("cnt1"),
                     "target_type": "content",
                 },
             ]
         }
     )
     assert node_writer.mock_calls == [
         call(f"swh:1:rel:{hexhash('rel1')}\n"),
         call(f"swh:1:rel:{hexhash('rel2')}\n"),
         call(f"swh:1:rel:{hexhash('rel3')}\n"),
         call(f"swh:1:rel:{hexhash('rel4')}\n"),
     ]
     assert edge_writer.mock_calls == [
         call(f"swh:1:rel:{hexhash('rel1')} swh:1:rev:{hexhash('rev1')}\n"),
         call(f"swh:1:rel:{hexhash('rel2')} swh:1:rel:{hexhash('rel1')}\n"),
         call(f"swh:1:rel:{hexhash('rel3')} swh:1:dir:{hexhash('dir1')}\n"),
         call(f"swh:1:rel:{hexhash('rel4')} swh:1:cnt:{hexhash('cnt1')}\n"),
     ]
 
 
 def test_export_revision(exporter):
     node_writer, edge_writer = exporter(
         {
             "revision": [
                 {
                     **TEST_REVISION,
                     "id": binhash("rev1"),
                     "directory": binhash("dir1"),
                     "parents": [binhash("rev2"), binhash("rev3"),],
                 },
                 {
                     **TEST_REVISION,
                     "id": binhash("rev2"),
                     "directory": binhash("dir2"),
                     "parents": [],
                 },
             ]
         }
     )
     assert node_writer.mock_calls == [
         call(f"swh:1:rev:{hexhash('rev1')}\n"),
         call(f"swh:1:rev:{hexhash('rev2')}\n"),
     ]
     assert edge_writer.mock_calls == [
         call(f"swh:1:rev:{hexhash('rev1')} swh:1:dir:{hexhash('dir1')}\n"),
         call(f"swh:1:rev:{hexhash('rev1')} swh:1:rev:{hexhash('rev2')}\n"),
         call(f"swh:1:rev:{hexhash('rev1')} swh:1:rev:{hexhash('rev3')}\n"),
         call(f"swh:1:rev:{hexhash('rev2')} swh:1:dir:{hexhash('dir2')}\n"),
     ]
 
 
 def test_export_directory(exporter):
     node_writer, edge_writer = exporter(
         {
             "directory": [
                 {
                     "id": binhash("dir1"),
                     "entries": [
                         {"type": "file", "target": binhash("cnt1")},
                         {"type": "dir", "target": binhash("dir2")},
                         {"type": "rev", "target": binhash("rev1")},
                     ],
                 },
                 {"id": binhash("dir2"), "entries": [],},
             ]
         }
     )
     assert node_writer.mock_calls == [
         call(f"swh:1:dir:{hexhash('dir1')}\n"),
         call(f"swh:1:dir:{hexhash('dir2')}\n"),
     ]
     assert edge_writer.mock_calls == [
         call(f"swh:1:dir:{hexhash('dir1')} swh:1:cnt:{hexhash('cnt1')}\n"),
         call(f"swh:1:dir:{hexhash('dir1')} swh:1:dir:{hexhash('dir2')}\n"),
         call(f"swh:1:dir:{hexhash('dir1')} swh:1:rev:{hexhash('rev1')}\n"),
     ]
 
 
 def test_export_content(exporter):
     node_writer, edge_writer = exporter(
         {
             "content": [
                 {**TEST_CONTENT, "sha1_git": binhash("cnt1"),},
                 {**TEST_CONTENT, "sha1_git": binhash("cnt2"),},
             ]
         }
     )
     assert node_writer.mock_calls == [
         call(f"swh:1:cnt:{hexhash('cnt1')}\n"),
         call(f"swh:1:cnt:{hexhash('cnt2')}\n"),
     ]
     assert edge_writer.mock_calls == []
 
 
 def test_export_duplicate_node(exporter):
     node_writer, edge_writer = exporter(
         {
             "content": [
                 {**TEST_CONTENT, "sha1_git": binhash("cnt1")},
                 {**TEST_CONTENT, "sha1_git": binhash("cnt1")},
                 {**TEST_CONTENT, "sha1_git": binhash("cnt1")},
             ],
         },
     )
     assert node_writer.mock_calls == [
         call(f"swh:1:cnt:{hexhash('cnt1')}\n"),
     ]
     assert edge_writer.mock_calls == []
 
 
 def test_export_duplicate_visit(exporter):
     node_writer, edge_writer = exporter(
         {
-            "origin_visit": [
-                {**TEST_ORIGIN_VISIT, "origin": {"url": "ori1"}, "visit": 1},
-                {**TEST_ORIGIN_VISIT, "origin": {"url": "ori2"}, "visit": 1},
-                {**TEST_ORIGIN_VISIT, "origin": {"url": "ori1"}, "visit": 1},
-                {**TEST_ORIGIN_VISIT, "origin": {"url": "ori2"}, "visit": 1},
-                {**TEST_ORIGIN_VISIT, "origin": {"url": "ori1"}, "visit": 2},
-                {**TEST_ORIGIN_VISIT, "origin": {"url": "ori2"}, "visit": 2},
-                {**TEST_ORIGIN_VISIT, "origin": {"url": "ori2"}, "visit": 2},
+            "origin_visit_status": [
+                {**TEST_ORIGIN_VISIT_STATUS, "origin": "ori1", "visit": 1},
+                {**TEST_ORIGIN_VISIT_STATUS, "origin": "ori2", "visit": 1},
+                {**TEST_ORIGIN_VISIT_STATUS, "origin": "ori1", "visit": 1},
+                {**TEST_ORIGIN_VISIT_STATUS, "origin": "ori2", "visit": 1},
+                {**TEST_ORIGIN_VISIT_STATUS, "origin": "ori1", "visit": 2},
+                {**TEST_ORIGIN_VISIT_STATUS, "origin": "ori2", "visit": 2},
+                {**TEST_ORIGIN_VISIT_STATUS, "origin": "ori2", "visit": 2},
             ],
         },
     )
     assert node_writer.mock_calls == [
         call(f"swh:1:ori:{hexhash('ori1')}\n"),
         call(f"swh:1:ori:{hexhash('ori2')}\n"),
         call(f"swh:1:ori:{hexhash('ori1')}\n"),
         call(f"swh:1:ori:{hexhash('ori2')}\n"),
     ]
     assert edge_writer.mock_calls == []
 
 
 def zstwrite(fp, lines):
     with ZSTFile(fp, "w") as writer:
         for line in lines:
             writer.write(line + "\n")
 
 
 def zstread(fp):
     with ZSTFile(fp, "r") as reader:
         return reader.read()
 
 
 def test_sort_pipeline(tmp_path):
     short_type_mapping = {
-        "origin_visit": "ori",
+        "origin_visit_status": "ori",
         "snapshot": "snp",
         "release": "rel",
         "revision": "rev",
         "directory": "dir",
         "content": "cnt",
     }
 
     input_nodes = [
         f"swh:1:{short}:{hexhash(short + str(x))}"
         for short in short_type_mapping.values()
         for x in range(4)
     ]
 
     input_edges = [
         f"swh:1:ori:{hexhash('ori1')} swh:1:snp:{hexhash('snp1')}",
         f"swh:1:ori:{hexhash('ori2')} swh:1:snp:{hexhash('snp2')}",
         f"swh:1:ori:{hexhash('ori3')} swh:1:snp:{hexhash('snp3')}",
         f"swh:1:ori:{hexhash('ori4')} swh:1:snp:{hexhash('snpX')}",  # missing dest
         f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev1')}",  # dup
         f"swh:1:snp:{hexhash('snp1')} swh:1:rev:{hexhash('rev1')}",  # dup
         f"swh:1:snp:{hexhash('snp3')} swh:1:cnt:{hexhash('cnt1')}",
         f"swh:1:snp:{hexhash('snp4')} swh:1:rel:{hexhash('rel1')}",
         f"swh:1:rel:{hexhash('rel1')} swh:1:rel:{hexhash('rel2')}",
         f"swh:1:rel:{hexhash('rel2')} swh:1:rev:{hexhash('rev1')}",
         f"swh:1:rel:{hexhash('rel3')} swh:1:rev:{hexhash('rev2')}",
         f"swh:1:rel:{hexhash('rel4')} swh:1:dir:{hexhash('dir1')}",
         f"swh:1:rev:{hexhash('rev1')} swh:1:rev:{hexhash('rev1')}",  # dup
         f"swh:1:rev:{hexhash('rev1')} swh:1:rev:{hexhash('rev1')}",  # dup
         f"swh:1:rev:{hexhash('rev1')} swh:1:rev:{hexhash('rev2')}",
         f"swh:1:rev:{hexhash('rev2')} swh:1:rev:{hexhash('revX')}",  # missing dest
         f"swh:1:rev:{hexhash('rev3')} swh:1:rev:{hexhash('rev2')}",
         f"swh:1:rev:{hexhash('rev4')} swh:1:dir:{hexhash('dir1')}",
         f"swh:1:dir:{hexhash('dir1')} swh:1:cnt:{hexhash('cnt1')}",
         f"swh:1:dir:{hexhash('dir1')} swh:1:dir:{hexhash('dir1')}",
         f"swh:1:dir:{hexhash('dir1')} swh:1:rev:{hexhash('rev1')}",
     ]
 
     for obj_type, short_obj_type in short_type_mapping.items():
         p = tmp_path / obj_type
         p.mkdir()
         edges = [e for e in input_edges if e.startswith(f"swh:1:{short_obj_type}")]
         zstwrite(p / "00.edges.csv.zst", edges[0::2])
         zstwrite(p / "01.edges.csv.zst", edges[1::2])
 
         nodes = [n for n in input_nodes if n.startswith(f"swh:1:{short_obj_type}")]
         zstwrite(p / "00.nodes.csv.zst", nodes[0::2])
         zstwrite(p / "01.nodes.csv.zst", nodes[1::2])
 
     sort_graph_nodes(tmp_path, config={"sort_buffer_size": "1M"})
 
     output_nodes = zstread(tmp_path / "graph.nodes.csv.zst").split("\n")
     output_edges = zstread(tmp_path / "graph.edges.csv.zst").split("\n")
     output_nodes = list(filter(bool, output_nodes))
     output_edges = list(filter(bool, output_edges))
 
     expected_nodes = set(input_nodes) | set(e.split()[1] for e in input_edges)
     assert output_nodes == sorted(expected_nodes)
     assert int((tmp_path / "graph.nodes.count.txt").read_text()) == len(expected_nodes)
 
     assert sorted(output_edges) == sorted(input_edges)
     assert int((tmp_path / "graph.edges.count.txt").read_text()) == len(input_edges)
 
     actual_node_stats = (tmp_path / "graph.nodes.stats.txt").read_text().strip()
     expected_node_stats = "\n".join(
         sorted(
             "{} {}".format(k, v)
             for k, v in collections.Counter(
                 node.split(":")[2] for node in expected_nodes
             ).items()
         )
     )
     assert actual_node_stats == expected_node_stats
 
     actual_edge_stats = (tmp_path / "graph.edges.stats.txt").read_text().strip()
     expected_edge_stats = "\n".join(
         sorted(
             "{} {}".format(k, v)
             for k, v in collections.Counter(
                 "{}:{}".format(edge.split(":")[2], edge.split(":")[5])
                 for edge in input_edges
             ).items()
         )
     )
     assert actual_edge_stats == expected_edge_stats