awindex 0.1.0__tar.gz

awindex-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aitherium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

awindex-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: awindex
+Version: 0.1.0
+Summary: Resolve .aither keywords and read the AitherNet Index (index.aitherium.com)
+Author: Aitherium
+License: MIT
+Project-URL: Homepage, https://index.aitherium.com
+Project-URL: Source, https://github.com/Aitherium/aithernet-index
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# awindex
+
+The AitherNet Index from the shell: a hand-curated map of the internet, kept in git.
+Every entry says who checked it and how.
+
+```bash
+pip install awindex
+awindex resolve neocities        # route + trust tier; exit 1 = not indexed
+awindex search "digital garden"
+awindex show neocities.org
+awindex --root records check     # validate a checkout of the index repo
+```
+
+It reads a local checkout of
+[Aitherium/aithernet-index](https://github.com/Aitherium/aithernet-index) when one is
+present, and https://index.aitherium.com otherwise. Stdlib only, Python 3.10+.
+
+Trust is computed from evidence, never typed in: **submitted**, **reachable** (the bot
+fetched it), **owner-proven** (the site serves `/.well-known/aithernet.json`), and
+**vouched** (two people other than the submitter).
+
+MIT. The index data is CC BY 4.0.

awindex-0.1.0/README.md

@@ -0,0 +1,22 @@
+# awindex
+
+The AitherNet Index from the shell: a hand-curated map of the internet, kept in git.
+Every entry says who checked it and how.
+
+```bash
+pip install awindex
+awindex resolve neocities        # route + trust tier; exit 1 = not indexed
+awindex search "digital garden"
+awindex show neocities.org
+awindex --root records check     # validate a checkout of the index repo
+```
+
+It reads a local checkout of
+[Aitherium/aithernet-index](https://github.com/Aitherium/aithernet-index) when one is
+present, and https://index.aitherium.com otherwise. Stdlib only, Python 3.10+.
+
+Trust is computed from evidence, never typed in: **submitted**, **reachable** (the bot
+fetched it), **owner-proven** (the site serves `/.well-known/aithernet.json`), and
+**vouched** (two people other than the submitter).
+
+MIT. The index data is CC BY 4.0.

awindex-0.1.0/awindex/__init__.py

@@ -0,0 +1,7 @@
+"""awindex: the AitherNet Index as a library and CLI."""
+
+__version__ = "0.1.0"
+
+from .netindex import TIERS, Index, Record, load, trust, validate  # noqa: E402
+
+__all__ = ["TIERS", "Index", "Record", "load", "trust", "validate", "__version__"]

awindex-0.1.0/awindex/cli.py

@@ -0,0 +1,170 @@
+"""awindex: resolve .aither keywords and read the AitherNet Index from the shell.
+
+    awindex resolve neocities.aither      # route + trust tier, exit 1 = not indexed
+    awindex search "digital garden"       # matching entries
+    awindex show neocities.org            # one record with its evidence
+    awindex check                         # validate a checkout (exit 0 / 1 / 2)
+    awindex --self-test
+
+Reads a local checkout when one exists (records/ beside the package, or
+AWINDEX_ROOT, or --root). Otherwise it reads the published index at
+https://index.aitherium.com, so a plain `pip install` works with no clone.
+Stdlib only.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import sys
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Optional
+
+from . import __version__, netindex
+
+BASE = "https://index.aitherium.com"
+UA = f"awindex/{__version__}"
+
+
+def _fetch(path: str) -> Optional[dict]:
+    req = urllib.request.Request(BASE + path, headers={"User-Agent": UA})
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:  # noqa: S310 (fixed https base)
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        if exc.code == 404:
+            return None
+        raise
+
+
+def _local(root: Optional[Path]) -> Optional[netindex.Index]:
+    root = root or netindex.DEFAULT_ROOT
+    if Path(root).is_dir():
+        records, _ = netindex.load(Path(root))
+        if records:
+            return netindex.Index(records)
+    return None
+
+
+def _record_dict(r: netindex.Record) -> dict:
+    return {"id": r.id, "kind": r.kind, "title": r.title, "url": r.url, "tags": r.tags,
+            "names": r.names, "route": r.route, "edges": r.edges,
+            "validated": r.provenance.get("validated", {}),
+            "trust": netindex.TIERS[netindex.trust(r)]}
+
+
+def cmd_resolve(name: str, idx: Optional[netindex.Index]) -> int:
+    name = name.strip().lower().rstrip(".")
+    if not name.endswith(netindex.NAME_SUFFIX):
+        name += netindex.NAME_SUFFIX
+    if idx is not None:
+        hit = idx.resolve(name)
+        if hit:
+            hit["trust"] = netindex.TIERS[netindex.trust(idx.records[hit["id"]])]
+    else:
+        hit = _fetch(f"/n/{name}.json")
+    if not hit:
+        print(f"NXDOMAIN {name}")
+        return 1
+    print(json.dumps(hit, indent=2))
+    return 0
+
+
+def _all(idx: Optional[netindex.Index]) -> list:
+    if idx is not None:
+        return [_record_dict(r) for r in idx.records.values()]
+    data = _fetch("/index.json") or {}
+    return data.get("records", [])
+
+
+def cmd_search(query: str, idx: Optional[netindex.Index], limit: int) -> int:
+    toks = [t for t in query.lower().split() if t]
+    scored = []
+    for r in _all(idx):
+        hay = " ".join([r["id"], r["title"], *r.get("tags", []), *r.get("names", [])]).lower()
+        s = sum(1 for t in toks if t in hay)
+        if s:
+            scored.append((-s, r["id"], r))
+    scored.sort(key=lambda x: (x[0], x[1]))
+    for _, _, r in scored[:limit]:
+        print(f"{r['trust']:<13} {r['kind']:<8} {r['title']}  {r.get('url', '')}")
+    return 0 if scored else 1
+
+
+def cmd_show(rid: str, idx: Optional[netindex.Index]) -> int:
+    for r in _all(idx):
+        if r["id"] == rid:
+            print(json.dumps(r, indent=2))
+            return 0
+    print(f"not indexed: {rid}")
+    return 1
+
+
+def cmd_check(root: Optional[Path]) -> int:
+    root = Path(root or netindex.DEFAULT_ROOT)
+    if not root.is_dir():
+        print(f"could not judge: {root} is not a directory")
+        return 2
+    records, findings = netindex.load(root)
+    if not records:
+        print(f"could not judge: no records under {root}")
+        return 2
+    findings += netindex.validate(records)
+    for f in findings:
+        print(f)
+    print(f"awindex: {len(records)} records, {len(findings)} findings")
+    return 1 if findings else 0
+
+
+def self_test() -> int:
+    good = netindex._parse(None, {
+        "id": "a", "kind": "site", "title": "A", "url": "https://a.example",
+        "tags": ["alpha"], "names": ["a.aither"],
+        "route": {"type": "web", "target": "https://a.example"},
+        "provenance": {"added_by": "t", "sources": ["x"],
+                       "validated": {"at": "2026-01-01", "by": "t", "method": "http-200"}}})
+    idx = netindex.Index([good])
+    checks = {
+        "resolve hit": idx.resolve("a.aither") is not None,
+        "resolve miss": idx.resolve("zz.aither") is None,
+        "trust reachable": netindex.TIERS[netindex.trust(good)] == "reachable",
+        "search": [r.id for r in idx.search("alpha")] == ["a"],
+    }
+    for k, v in checks.items():
+        print(f"{'PASS' if v else 'FAIL'} {k}")
+    return 0 if all(checks.values()) else 1
+
+
+def main(argv: Optional[list] = None) -> int:
+    ap = argparse.ArgumentParser(prog="awindex", description=__doc__.splitlines()[0])
+    ap.add_argument("--root", type=Path, help="a records/ directory (default: local or web)")
+    ap.add_argument("--web", action="store_true", help="ignore any local checkout")
+    ap.add_argument("--self-test", action="store_true")
+    ap.add_argument("--version", action="version", version=f"awindex {__version__}")
+    sub = ap.add_subparsers(dest="cmd")
+    sub.add_parser("resolve").add_argument("name")
+    s = sub.add_parser("search")
+    s.add_argument("query")
+    s.add_argument("--limit", type=int, default=20)
+    sub.add_parser("show").add_argument("id")
+    sub.add_parser("check")
+    a = ap.parse_args(argv)
+    if a.self_test:
+        return self_test()
+    if a.cmd == "check":
+        return cmd_check(a.root)
+    idx = None if a.web else _local(a.root)
+    if a.cmd == "resolve":
+        return cmd_resolve(a.name, idx)
+    if a.cmd == "search":
+        return cmd_search(a.query, idx, a.limit)
+    if a.cmd == "show":
+        return cmd_show(a.id, idx)
+    ap.print_help()
+    return 2
+
+
+if __name__ == "__main__":
+    sys.exit(main())

awindex-0.1.0/awindex/netindex.py

@@ -0,0 +1,228 @@
+"""AitherNet Index: a curated, validated internet graph that lives in git.
+
+One JSON file per entity under ``records/``. The file
+IS the record; git history is the audit log; a pull request is how a
+contribution arrives (from a person, awfind/awresearch harvest, ShadowBroker
+gates or the Tagalong Town residents). Nothing here crawls or fetches: this
+module loads, validates, resolves names and walks edges. Validation that needs
+the network (is the URL alive) is recorded IN the record by whoever checked it,
+under ``provenance.validated``, so a reviewer can re-run it.
+
+Name resolution is the AitherNet DNS/router seam: ``resolve("docs.aither")``
+returns the route a client should take. Two records claiming one name is a
+validation error (NI003), never a silent first-wins.
+
+Python 3.10 compatible; stdlib only.
+"""
+
+from __future__ import annotations
+
+import datetime as _dt
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable, Optional
+
+# A checkout of the index repo (records/ beside the package), or AWINDEX_ROOT.
+# A pip install has no records/: the CLI then reads index.aitherium.com instead.
+DEFAULT_ROOT = Path(os.environ.get("AWINDEX_ROOT")
+                    or Path(__file__).resolve().parents[1] / "records")
+
+# garden = a personal digital garden (Neocities-style); room = an AitherRelay channel;
+# space = an AitherSpace. A .aither name on any of them is its AOL-style keyword.
+KINDS = {"site", "service", "org", "gate", "world", "dataset",
+         "garden", "room", "space"}
+ROUTE_TYPES = {"web", "aithernet", "relay-gate", "world", "relay-room", "space"}
+EDGE_RELS = {"owned_by", "links_to", "mirrors", "part_of", "bridges", "about", "alternative_to"}
+NAME_SUFFIX = ".aither"
+
+
+@dataclass
+class Finding:
+    code: str
+    record: str
+    message: str
+
+    def __str__(self) -> str:
+        return f"{self.code} {self.record}: {self.message}"
+
+
+@dataclass
+class Record:
+    id: str
+    kind: str
+    title: str
+    url: str = ""
+    tags: list = field(default_factory=list)
+    names: list = field(default_factory=list)
+    route: dict = field(default_factory=dict)
+    edges: list = field(default_factory=list)
+    provenance: dict = field(default_factory=dict)
+    path: Optional[Path] = None
+
+
+def _parse(path: Path, raw: dict) -> Record:
+    return Record(
+        id=raw.get("id", ""),
+        kind=raw.get("kind", ""),
+        title=raw.get("title", ""),
+        url=raw.get("url", ""),
+        tags=list(raw.get("tags") or []),
+        names=list(raw.get("names") or []),
+        route=dict(raw.get("route") or {}),
+        edges=list(raw.get("edges") or []),
+        provenance=dict(raw.get("provenance") or {}),
+        path=path,
+    )
+
+
+def load(root: Path = DEFAULT_ROOT) -> "tuple[list[Record], list[Finding]]":
+    """Load every record. Unreadable JSON is a finding, not an exception."""
+    records: list = []
+    findings: list = []
+    for path in sorted(Path(root).rglob("*.json")):
+        try:
+            raw = json.loads(path.read_text(encoding="utf-8"))
+        except (OSError, ValueError) as exc:
+            findings.append(Finding("NI000", path.name, f"unreadable JSON: {exc}"))
+            continue
+        if not isinstance(raw, dict):
+            findings.append(Finding("NI000", path.name, "top level is not an object"))
+            continue
+        records.append(_parse(path, raw))
+    return records, findings
+
+
+def validate(records: Iterable[Record], today: Optional[_dt.date] = None) -> "list[Finding]":
+    """Every rule the index must hold. Empty list = clean."""
+    today = today or _dt.date.today()
+    recs = list(records)
+    out: list = []
+    ids = {}
+    for r in recs:
+        if r.id in ids:
+            out.append(Finding("NI002", r.id, f"duplicate id (also {ids[r.id]})"))
+        ids[r.id] = r.path.name if r.path else r.id
+
+    names: dict = {}
+    for r in recs:
+        rid = r.id or (r.path.name if r.path else "?")
+        if not r.id or not r.title:
+            out.append(Finding("NI001", rid, "id and title are required"))
+        if r.kind not in KINDS:
+            out.append(Finding("NI001", rid, f"kind {r.kind!r} not in {sorted(KINDS)}"))
+        if r.path is not None and r.path.stem != r.id.replace(":", "_"):
+            out.append(Finding("NI002", rid, f"file name {r.path.name} != id"))
+        if r.url and not r.url.startswith("https://"):
+            out.append(Finding("NI007", rid, "url must be https://"))
+        for n in r.names:
+            if not isinstance(n, str) or not n.endswith(NAME_SUFFIX) or n != n.lower():
+                msg = f"name {n!r} must be lowercase and end in {NAME_SUFFIX}"
+                out.append(Finding("NI005", rid, msg))
+            if n in names:
+                out.append(Finding("NI003", rid, f"name {n!r} already claimed by {names[n]}"))
+            names.setdefault(n, rid)
+        if r.names:
+            rtype = r.route.get("type")
+            if rtype not in ROUTE_TYPES or not r.route.get("target"):
+                msg = f"a named record needs route.type in {sorted(ROUTE_TYPES)} and route.target"
+                out.append(Finding("NI006", rid, msg))
+            elif rtype == "web" and not str(r.route["target"]).startswith("https://"):
+                out.append(Finding("NI007", rid, "web route target must be https://"))
+        for e in r.edges:
+            rel, to = (e or {}).get("rel"), (e or {}).get("to")
+            if rel not in EDGE_RELS:
+                out.append(Finding("NI004", rid, f"edge rel {rel!r} not in {sorted(EDGE_RELS)}"))
+            if to not in ids:
+                out.append(Finding("NI004", rid, f"edge to unknown record {to!r}"))
+        prov = r.provenance
+        val = prov.get("validated") or {}
+        if not prov.get("added_by") or not prov.get("sources"):
+            msg = "provenance.added_by and provenance.sources are required"
+            out.append(Finding("NI008", rid, msg))
+        if not val.get("at") or not val.get("by") or not val.get("method"):
+            out.append(Finding("NI008", rid, "provenance.validated needs at, by, method"))
+        else:
+            try:
+                when = _dt.date.fromisoformat(str(val["at"]))
+            except ValueError:
+                out.append(Finding("NI008", rid, f"validated.at {val['at']!r} is not YYYY-MM-DD"))
+            else:
+                if when > today:
+                    out.append(Finding("NI008", rid, f"validated.at {when} is in the future"))
+        seen = set()
+        for v in prov.get("vouches") or []:
+            who = (v or {}).get("by")
+            if not who or not (v or {}).get("at"):
+                out.append(Finding("NI009", rid, "a vouch needs by and at"))
+            elif who == prov.get("added_by"):
+                out.append(Finding("NI009", rid, f"{who} cannot vouch for their own submission"))
+            elif who in seen:
+                out.append(Finding("NI009", rid, f"{who} vouched twice"))
+            seen.add(who)
+    return out
+
+
+# Trust is COMPUTED from evidence in the record, never typed in by a contributor.
+# A submitter can claim anything; only these facts move an entry up a tier.
+TIERS = {0: "submitted", 1: "reachable", 2: "owner-proven", 3: "vouched"}
+_REACH_METHODS = {"http-200"}
+_OWNER_METHODS = {"well-known", "owner-asserted"}
+
+
+def trust(r: Record) -> int:
+    """0 submitted · 1 reachable (bot fetched it) · 2 owner-proven (the site serves
+    /.well-known/aithernet.json naming this id) · 3 vouched (reachable or better AND
+    at least two distinct people other than the submitter vouched)."""
+    method = (r.provenance.get("validated") or {}).get("method", "")
+    tier = 2 if method in _OWNER_METHODS else 1 if method in _REACH_METHODS else 0
+    vouchers = {v.get("by") for v in r.provenance.get("vouches") or [] if v.get("by")}
+    vouchers.discard(r.provenance.get("added_by"))
+    if tier >= 1 and len(vouchers) >= 2:
+        tier = 3
+    return tier
+
+
+class Index:
+    """In-memory view: name -> route, id -> record, edge walks."""
+
+    def __init__(self, records: Iterable[Record]):
+        self.records = {r.id: r for r in records}
+        self.names = {n: r.id for r in self.records.values() for n in r.names}
+
+    @classmethod
+    def from_root(cls, root: Path = DEFAULT_ROOT) -> "Index":
+        recs, _ = load(root)
+        return cls(recs)
+
+    def resolve(self, name: str) -> Optional[dict]:
+        """The AitherNet DNS seam. None = NXDOMAIN; never a guess."""
+        rid = self.names.get(name.strip().lower().rstrip("."))
+        if rid is None:
+            return None
+        r = self.records[rid]
+        return {"name": name, "id": r.id, "kind": r.kind, **r.route}
+
+    def neighbours(self, rid: str) -> "list[tuple[str, str, str]]":
+        """(direction, rel, other_id) for every edge touching ``rid``."""
+        out = []
+        for r in self.records.values():
+            for e in r.edges:
+                if r.id == rid:
+                    out.append(("out", e.get("rel", ""), e.get("to", "")))
+                elif e.get("to") == rid:
+                    out.append(("in", e.get("rel", ""), r.id))
+        return out
+
+    def search(self, query: str, limit: int = 10) -> "list[Record]":
+        """Plain token match over id/title/tags; the AitherSearch provider seam."""
+        toks = [t for t in query.lower().split() if t]
+        scored = []
+        for r in self.records.values():
+            hay = " ".join([r.id, r.title, *r.tags, *r.names]).lower()
+            s = sum(1 for t in toks if t in hay)
+            if s:
+                scored.append((s, r.id, r))
+        scored.sort(key=lambda x: (-x[0], x[1]))
+        return [r for _, _, r in scored[:limit]]

awindex-0.1.0/awindex.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: awindex
+Version: 0.1.0
+Summary: Resolve .aither keywords and read the AitherNet Index (index.aitherium.com)
+Author: Aitherium
+License: MIT
+Project-URL: Homepage, https://index.aitherium.com
+Project-URL: Source, https://github.com/Aitherium/aithernet-index
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# awindex
+
+The AitherNet Index from the shell: a hand-curated map of the internet, kept in git.
+Every entry says who checked it and how.
+
+```bash
+pip install awindex
+awindex resolve neocities        # route + trust tier; exit 1 = not indexed
+awindex search "digital garden"
+awindex show neocities.org
+awindex --root records check     # validate a checkout of the index repo
+```
+
+It reads a local checkout of
+[Aitherium/aithernet-index](https://github.com/Aitherium/aithernet-index) when one is
+present, and https://index.aitherium.com otherwise. Stdlib only, Python 3.10+.
+
+Trust is computed from evidence, never typed in: **submitted**, **reachable** (the bot
+fetched it), **owner-proven** (the site serves `/.well-known/aithernet.json`), and
+**vouched** (two people other than the submitter).
+
+MIT. The index data is CC BY 4.0.

awindex-0.1.0/awindex.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+awindex/__init__.py
+awindex/cli.py
+awindex/netindex.py
+awindex.egg-info/PKG-INFO
+awindex.egg-info/SOURCES.txt
+awindex.egg-info/dependency_links.txt
+awindex.egg-info/entry_points.txt
+awindex.egg-info/top_level.txt
+tests/test_awindex.py

awindex-0.1.0/awindex.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

awindex-0.1.0/awindex.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+awindex = awindex.cli:main

awindex-0.1.0/awindex.egg-info/top_level.txt

@@ -0,0 +1 @@
+awindex

awindex-0.1.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "awindex"
+version = "0.1.0"
+description = "Resolve .aither keywords and read the AitherNet Index (index.aitherium.com)"
+readme = "README.md"
+requires-python = ">=3.10"
+license = {text = "MIT"}
+authors = [{name = "Aitherium"}]
+
+[project.urls]
+Homepage = "https://index.aitherium.com"
+Source = "https://github.com/Aitherium/aithernet-index"
+
+[project.scripts]
+awindex = "awindex.cli:main"
+
+[tool.setuptools]
+packages = ["awindex"]

awindex-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

awindex-0.1.0/tests/test_awindex.py

@@ -0,0 +1,42 @@
+"""awindex contract: offline resolve, search, trust and check over a temp checkout."""
+import json
+
+from awindex import cli, netindex
+
+
+def _write(root, rec):
+    (root / f"{rec['id']}.json").write_text(json.dumps(rec), encoding="utf-8")
+
+
+REC = {"id": "a.example", "kind": "site", "title": "A", "url": "https://a.example",
+       "tags": ["alpha"], "names": ["a.aither"],
+       "route": {"type": "web", "target": "https://a.example"},
+       "provenance": {"added_by": "t", "sources": ["x"],
+                      "validated": {"at": "2026-01-01", "by": "t", "method": "http-200"}}}
+
+
+def test_self_test_passes():
+    assert cli.main(["--self-test"]) == 0
+
+
+def test_resolve_and_search_offline(tmp_path, capsys):
+    _write(tmp_path, REC)
+    assert cli.main(["--root", str(tmp_path), "resolve", "a"]) == 0
+    assert '"target": "https://a.example"' in capsys.readouterr().out
+    assert cli.main(["--root", str(tmp_path), "resolve", "zz"]) == 1
+    assert cli.main(["--root", str(tmp_path), "search", "alpha"]) == 0
+
+
+def test_check_flags_a_name_collision(tmp_path):
+    _write(tmp_path, REC)
+    _write(tmp_path, {**REC, "id": "b.example"})
+    assert cli.main(["--root", str(tmp_path), "check"]) == 1
+
+
+def test_check_on_nothing_cannot_judge(tmp_path):
+    assert cli.main(["--root", str(tmp_path), "check"]) == 2
+
+
+def test_trust_is_computed_not_typed():
+    r = netindex._parse(None, {**REC, "trust": "vouched"})
+    assert netindex.TIERS[netindex.trust(r)] == "reachable"