"""Ecosystem Lineage Explorer — FastAPI + SQLite (read-only) + vis-network.

- Overview: analysis dashboard (relationship-type mix, most-copied, most-derived,
  most-translated, most-prolific producers) over the inferred lineage graph.
- Explorer: search/pick a repo -> interactive lineage graph + related lists.
- API: GET /related?dataset=<id>&kind=<kind>, /api/graph, /analysis, /examples, /stats.

Nodes are (id, kind) where kind is 'dataset' or 'model'; edges carry the kind of
each endpoint. The schema is auto-detected: a dataset-only db (no kind columns)
is served exactly as before with everything defaulting to kind='dataset'.

DB is opened read-only; lineage.db is baked into the repo (small, robust).
Edward Tufte-inspired styling.
"""

import json
import os
import sqlite3
from functools import lru_cache
from pathlib import Path

from fastapi import FastAPI, HTTPException, Query, Request
from fastapi.middleware.gzip import GZipMiddleware
from fastapi.responses import HTMLResponse, JSONResponse

# DB selection order:
#  1. LINEAGE_DB env var (dev: point at a sample/full db without editing anything)
#  2. the bucket-mounted DB (/data/lineage.db, persistent + can grow)
#  3. the baked-in copy (cold-mount fail, local dev) so the Space stays up either way.
ENV_DB = os.environ.get("LINEAGE_DB")
BUCKET_DB = Path("/data/lineage.db")
LOCAL_DB = Path(__file__).parent / "lineage.db"
if ENV_DB:
    DB = Path(ENV_DB)
elif BUCKET_DB.exists():
    DB = BUCKET_DB
else:
    DB = LOCAL_DB
print(f"using DB: {DB} (env={bool(ENV_DB)} bucket-mount={BUCKET_DB.exists()})", flush=True)
# High safety ceiling only — stops a depth-2 hub exploding to tens of thousands
# of nodes. The per-node degree cap (see graph()) is the primary anti-hairball.
MAX_NODES = 2500
# Composite node key delimiter (id + kind). Unit-separator can't occur in a repo id.
SEP = "\x1f"
app = FastAPI(title="Ecosystem Lineage Explorer")
app.add_middleware(GZipMiddleware, minimum_size=500)
_con = sqlite3.connect(f"file:{DB}?mode=ro", uri=True, check_same_thread=False)
_con.row_factory = sqlite3.Row


def _cols(table: str) -> set[str]:
    return {r[1] for r in _con.execute(f"PRAGMA table_info({table})").fetchall()}


# Schema auto-detection: the model extension adds a `kind` column to nodes and
# `child_kind`/`parent_kind` to edges. When absent (dataset-only db) every query
# falls back to the original form and synthesises kind='dataset'.
_NODE_COLS = _cols("nodes")
_EDGE_COLS = _cols("edges")
_TABLES = {r[0] for r in _con.execute("SELECT name FROM sqlite_master WHERE type='table'").fetchall()}
HAS_NODE_KIND = "kind" in _NODE_COLS
HAS_EDGE_KIND = "child_kind" in _EDGE_COLS and "parent_kind" in _EDGE_COLS
# Optional precomputed downstream-footprint table (dataset -> models trained on it ->
# their derivative closure). When absent (or empty), the UI surfaces that use it hide.
HAS_IMPACT = "dataset_impact" in _TABLES
# Optional precomputed trending-enablement table (top trending models + their upward
# provenance chain as JSON). Absent -> the Overview table hides.
HAS_TRENDING = "trending_enablement" in _TABLES
# Time-evolution data: nodes.created_at (ISO, nullable) drives the Explorer scrubber;
# the precomputed `timeline` table drives the Overview "Over time" charts. Either
# absent -> the corresponding surface hides.
HAS_CREATED_AT = "created_at" in _NODE_COLS
HAS_TIMELINE = "timeline" in _TABLES
# Optional one-row build-provenance table (built_at, cutoff) stamped by build_db.
# Absent on older dbs -> the "data as of" line hides.
HAS_META = "meta" in _TABLES
print(f"schema: node_kind={HAS_NODE_KIND} edge_kind={HAS_EDGE_KIND} impact={HAS_IMPACT} "
      f"trending={HAS_TRENDING} created_at={HAS_CREATED_AT} timeline={HAS_TIMELINE} "
      f"meta={HAS_META}", flush=True)

# node identity is (id, kind); kind comes from user query params, so validate it —
# an unbounded set of kinds would otherwise poison the bounded per-kind lru_caches.
VALID_KINDS = ("dataset", "model")


def _check_kind(kind: str) -> str:
    if kind not in VALID_KINDS:
        raise HTTPException(status_code=400, detail="kind must be 'dataset' or 'model'")
    return kind


def _built_meta() -> dict:
    if not HAS_META:
        return {}
    return {r[0]: r[1] for r in _con.execute("SELECT key, value FROM meta").fetchall()}


@lru_cache(maxsize=2048)
def _impact(dataset: str) -> dict | None:
    """Downstream model footprint for one dataset, or None (no table / not found)."""
    if not HAS_IMPACT:
        return None
    r = _con.execute(
        "SELECT direct_models, descendant_models, descendant_downloads "
        "FROM dataset_impact WHERE dataset_id=?", (dataset,)
    ).fetchone()
    return dict(r) if r else None


@app.middleware("http")
async def cache_headers(request: Request, call_next):
    resp = await call_next(request)
    if request.url.path.startswith(("/api", "/related", "/examples", "/stats", "/analysis")):
        resp.headers["Cache-Control"] = "public, max-age=86400"
    return resp


@lru_cache(maxsize=8192)
def _meta(dataset: str, kind: str = "dataset") -> dict:
    if HAS_NODE_KIND:
        r = _con.execute("SELECT * FROM nodes WHERE dataset_id=? AND kind=?", (dataset, kind)).fetchone()
    else:
        r = _con.execute("SELECT * FROM nodes WHERE dataset_id=?", (dataset,)).fetchone()
    if r:
        d = dict(r)
        d.setdefault("kind", kind)
        return d
    return {"dataset_id": dataset, "kind": kind, "downloads": 0, "likes": 0, "author": ""}


@lru_cache(maxsize=8192)
def parents(dataset: str, kind: str = "dataset") -> list[dict]:
    if HAS_EDGE_KIND:
        rows = _con.execute(
            "SELECT parent AS id, parent_kind AS kind, primary_type, confidence, tags, size_ratio, source "
            "FROM edges WHERE child=? AND child_kind=? ORDER BY confidence DESC", (dataset, kind)
        ).fetchall()
    else:
        rows = _con.execute(
            "SELECT parent AS id, 'dataset' AS kind, primary_type, confidence, tags, size_ratio, source "
            "FROM edges WHERE child=? ORDER BY confidence DESC", (dataset,)
        ).fetchall()
    return [dict(r) for r in rows]


@lru_cache(maxsize=8192)
def children(dataset: str, kind: str = "dataset") -> list[dict]:
    if HAS_EDGE_KIND:
        rows = _con.execute(
            "SELECT child AS id, child_kind AS kind, primary_type, confidence, tags, size_ratio, source "
            "FROM edges WHERE parent=? AND parent_kind=? ORDER BY confidence DESC", (dataset, kind)
        ).fetchall()
    else:
        rows = _con.execute(
            "SELECT child AS id, 'dataset' AS kind, primary_type, confidence, tags, size_ratio, source "
            "FROM edges WHERE parent=? ORDER BY confidence DESC", (dataset,)
        ).fetchall()
    return [dict(r) for r in rows]


def siblings(dataset: str, kind: str = "dataset") -> list[dict]:
    if HAS_EDGE_KIND:
        rows = _con.execute(
            "SELECT DISTINCT e2.child AS id, e2.child_kind AS kind, e2.parent AS via, e2.primary_type "
            "FROM edges e1 JOIN edges e2 ON e1.parent=e2.parent AND e1.parent_kind=e2.parent_kind "
            "WHERE e1.child=? AND e1.child_kind=? AND NOT (e2.child=? AND e2.child_kind=?) LIMIT 80",
            (dataset, kind, dataset, kind)
        ).fetchall()
    else:
        rows = _con.execute(
            "SELECT DISTINCT e2.child AS id, 'dataset' AS kind, e2.parent AS via, e2.primary_type "
            "FROM edges e1 JOIN edges e2 ON e1.parent=e2.parent "
            "WHERE e1.child=? AND e2.child!=? LIMIT 80", (dataset, dataset)
        ).fetchall()
    return [dict(r) for r in rows]


def related(dataset: str, kind: str = "dataset") -> dict:
    out = {"dataset": dataset, "kind": kind, "meta": _meta(dataset, kind),
           "parents": parents(dataset, kind), "children": children(dataset, kind),
           "siblings": siblings(dataset, kind)}
    if kind == "dataset":  # only datasets carry a downstream footprint
        imp = _impact(dataset)
        if imp:
            out["impact"] = imp
    return out


@app.get("/related")
def related_endpoint(
    dataset: str = Query(..., description="repo id, e.g. tatsu-lab/alpaca"),
    kind: str = Query("dataset", description="dataset | model"),
):
    """JSON of parents/children/siblings — for metadata workflows."""
    return JSONResponse(related(dataset, _check_kind(kind)))


@app.get("/api/graph")
def graph(dataset: str, kind: str = "dataset", depth: int = 2, cap: int = 25):
    """Bounded lineage graph. `cap` = max edges rendered per node, per direction,
    PER counterpart-kind (top-N by confidence within each kind bucket). Each
    truncated bucket collapses into its own muted "+K more <kind>s" aggregate node,
    so a mixed family always shows BOTH kinds — thousands of models trained on a
    dataset can't crowd its dataset-derivatives off the canvas. Nodes are keyed by
    (id, kind); edges reference those keys."""
    _check_kind(kind)
    cap = min(max(1, cap), 200)  # clamp: a huge cap would render every edge of a hub node
    depth = min(max(1, depth), 4)

    def nk(i: str, k: str) -> str:
        return k + SEP + i

    focus = nk(dataset, kind)
    nodes: dict[str, tuple[str, str]] = {focus: (dataset, kind)}
    seen_edges: list[tuple] = []
    # (direction, bucket_kind, attach_key) -> count of hidden tail edges for that kind
    aggregates: dict[tuple[str, str, str], int] = {}

    def expand(frontier, get_fn, direction):
        nxt = set()
        for d, dk in frontier:
            if len(nodes) >= MAX_NODES:
                break
            buckets: dict[str, list] = {}
            for r in get_fn(d, dk):  # already ORDER BY confidence DESC
                buckets.setdefault(r["kind"], []).append(r)
            for bkind, rows in buckets.items():
                for r in rows[:cap]:
                    rk = nk(r["id"], r["kind"])
                    a, b = (rk, nk(d, dk)) if direction == "up" else (nk(d, dk), rk)
                    seen_edges.append((a, b, r["primary_type"], r["confidence"], r["source"]))
                    if rk not in nodes and len(nodes) < MAX_NODES:
                        nodes[rk] = (r["id"], r["kind"])
                        nxt.add((r["id"], r["kind"]))
                if len(rows) > cap:
                    aggregates[(direction, bkind, nk(d, dk))] = len(rows) - cap
        return nxt

    frontier = {(dataset, kind)}
    for _ in range(max(1, min(depth, 4))):
        frontier = expand(frontier, parents, "up")
        if len(nodes) >= MAX_NODES:
            break
    frontier = {(dataset, kind)}
    for _ in range(max(1, min(depth, 4))):
        frontier = expand(frontier, children, "down")
        if len(nodes) >= MAX_NODES:
            break

    edges_seen = {(a, b): (t, cf, s) for a, b, t, cf, s in seen_edges}
    node_list = []
    for key, (i, kk) in nodes.items():
        m = _meta(i, kk)
        node_list.append({"key": key, "id": i, "kind": kk, "label": i.split("/")[-1],
                          "title": f"{i} ({m['downloads']:,} dl)",
                          "downloads": m["downloads"], "created_at": m.get("created_at"),
                          "focus": key == focus})
    edge_list = [{"from": a, "to": b, "type": t, "confidence": cf, "source": s}
                 for (a, b), (t, cf, s) in edges_seen.items() if a in nodes and b in nodes]

    # One synthetic aggregate node per truncated (direction, kind) bucket
    # (not clickable client-side); its label names the kind so both are legible.
    for (direction, bkind, akey), count in aggregates.items():
        aid = "agg" + SEP + direction + SEP + bkind + SEP + akey
        node_list.append({"key": aid, "id": aid, "kind": "aggregate", "agg": True, "aggkind": bkind,
                          "label": f"+{count:,} more {bkind}s", "count": count,
                          "title": f"{count:,} more {bkind}s not shown (top {cap} by confidence rendered)",
                          "downloads": 0, "focus": False})
        if direction == "up":
            edge_list.append({"from": aid, "to": akey, "type": "aggregate", "confidence": 0, "source": "aggregate"})
        else:
            edge_list.append({"from": akey, "to": aid, "type": "aggregate", "confidence": 0, "source": "aggregate"})

    return {"nodes": node_list, "edges": edge_list}


@lru_cache(maxsize=1)
def _stats():
    n = _con.execute("SELECT count(*) FROM nodes").fetchone()[0]
    e = _con.execute("SELECT count(*) FROM edges").fetchone()[0]
    inf = _con.execute("SELECT count(*) FROM edges WHERE source='inferred'").fetchone()[0]
    deriv = _con.execute("SELECT count(DISTINCT child) FROM edges WHERE source='inferred'").fetchone()[0]
    # Datasets that actually appear in the inferred lineage (as parent or child) —
    # the population the derivative-rate is measured against. NOT all dataset nodes:
    # the model layer drags in trained_on-only parents that were never analysed for
    # derivation, so measuring the rate against them would understate it.
    lineage_datasets = _con.execute(
        "SELECT count(*) FROM (SELECT parent d FROM edges WHERE source='inferred' "
        "UNION SELECT child FROM edges WHERE source='inferred')"
    ).fetchone()[0]
    if HAS_NODE_KIND:
        dataset_nodes = _con.execute("SELECT count(*) FROM nodes WHERE kind='dataset'").fetchone()[0]
        model_nodes = _con.execute("SELECT count(*) FROM nodes WHERE kind='model'").fetchone()[0]
    else:
        dataset_nodes, model_nodes = n, 0
    declared_edges = _con.execute("SELECT count(*) FROM edges WHERE source='declared_tag'").fetchone()[0]
    bm = _built_meta()  # built_at / cutoff when the db carries them (else absent)
    return {"nodes": n, "edges": e, "inferred": inf, "derivatives": deriv,
            "lineage_datasets": lineage_datasets, "dataset_nodes": dataset_nodes,
            "model_nodes": model_nodes, "declared_edges": declared_edges,
            "built_at": bm.get("built_at"), "cutoff": bm.get("cutoff")}


@lru_cache(maxsize=8)
def _examples(n: int):
    if HAS_EDGE_KIND:
        rows = _con.execute(
            "SELECT parent AS id, parent_kind AS kind, count(*) AS derivatives FROM edges "
            "WHERE source='inferred' GROUP BY parent, parent_kind ORDER BY derivatives DESC LIMIT ?", (n,)
        ).fetchall()
    else:
        rows = _con.execute(
            "SELECT parent AS id, 'dataset' AS kind, count(*) AS derivatives FROM edges "
            "WHERE source='inferred' GROUP BY parent ORDER BY derivatives DESC LIMIT ?", (n,)
        ).fetchall()
    return [dict(r) for r in rows]


@lru_cache(maxsize=1)
def _analysis():
    def top(sql, *a):
        return [dict(r) for r in _con.execute(sql, a).fetchall()]

    res = {
        "type_dist": top("SELECT primary_type t, count(*) n FROM edges WHERE source='inferred' "
                         "GROUP BY t ORDER BY n DESC"),
        "most_copied": top("SELECT parent id, count(*) n FROM edges WHERE primary_type='exact_copy' "
                           "GROUP BY parent ORDER BY n DESC LIMIT 12"),
        "most_derived": top("SELECT parent id, count(*) n FROM edges WHERE source='inferred' "
                            "GROUP BY parent ORDER BY n DESC LIMIT 12"),
        "most_translated": top("SELECT parent id, count(*) n FROM edges WHERE primary_type='translation' "
                               "GROUP BY parent ORDER BY n DESC LIMIT 10"),
        "top_orgs": top("SELECT substr(child,1,instr(child,'/')-1) id, count(*) n FROM edges "
                        "WHERE source='inferred' AND instr(child,'/')>0 GROUP BY id ORDER BY n DESC LIMIT 12"),
    }
    if HAS_IMPACT:  # datasets whose trained-on model closure has the largest download footprint
        res["downstream_footprint"] = top(
            "SELECT dataset_id id, direct_models, descendant_models, descendant_downloads "
            "FROM dataset_impact ORDER BY descendant_downloads DESC LIMIT 12")
    if HAS_TRENDING:  # top trending models + their upward provenance chain (ancestry JSON)
        rows = _con.execute(
            "SELECT model_id, trending_score, ancestry FROM trending_enablement "
            "ORDER BY trending_score DESC LIMIT 12").fetchall()
        out = []
        for r in rows:
            try:
                anc = json.loads(r["ancestry"]) if r["ancestry"] else []
            except (ValueError, TypeError):
                anc = []
            out.append({"id": r["model_id"], "trending_score": r["trending_score"], "ancestry": anc})
        res["trending_enablement"] = out
    if HAS_TIMELINE:
        # tidy long table (period, series, category, count) -> parallel arrays aligned
        # on a shared sorted period axis: {periods, nodes:{kind:[..]}, edges:{type:[..]}}
        try:
            rows = _con.execute("SELECT period, series, category, count FROM timeline").fetchall()
            periods = sorted({r["period"] for r in rows})
            pidx = {p: i for i, p in enumerate(periods)}
            nodes_s: dict[str, list] = {}
            edges_s: dict[str, list] = {}
            for r in rows:
                tgt = nodes_s if r["series"] == "node" else edges_s
                tgt.setdefault(r["category"], [0] * len(periods))[pidx[r["period"]]] = r["count"]
            if periods:
                res["timeline"] = {"periods": periods, "nodes": nodes_s, "edges": edges_s}
        except sqlite3.Error:
            pass  # unexpected timeline shape -> surface hides, everything else fine
    return res


@lru_cache(maxsize=1)
def _map():
    """Overview map: multi-level chains (a derivative that is itself derived-from)
    + the top fan-out hubs. Nodes sized by derivative count. This view is the
    inferred dataset-lineage backbone, so its nodes are datasets."""
    counts = dict(_con.execute(
        "SELECT parent, count(*) FROM edges WHERE source='inferred' GROUP BY parent"
    ).fetchall())
    backbone = _con.execute(
        "SELECT parent, child, primary_type, confidence FROM edges WHERE source='inferred' "
        "AND child IN (SELECT DISTINCT parent FROM edges WHERE source='inferred')"
    ).fetchall()
    nodeset, edges = set(), []
    for r in backbone:
        nodeset.add(r["parent"])
        nodeset.add(r["child"])
        edges.append({"from": r["parent"], "to": r["child"],
                      "type": r["primary_type"], "confidence": r["confidence"]})
    for pid, _n in sorted(counts.items(), key=lambda x: -x[1])[:60]:
        nodeset.add(pid)
    nodes = [{"id": n, "kind": "dataset", "label": n.split("/")[-1], "derivatives": counts.get(n, 0),
              "downloads": _meta(n)["downloads"], "created_at": _meta(n).get("created_at")}
             for n in nodeset]
    return {"nodes": nodes, "edges": edges}


@app.get("/api/map")
def api_map():
    return _map()


@lru_cache(maxsize=4096)
def _search(q: str) -> list[dict]:
    if HAS_NODE_KIND:
        rows = _con.execute(
            "SELECT n.dataset_id AS id, n.kind AS kind, n.downloads, "
            "(SELECT count(*) FROM edges WHERE parent=n.dataset_id AND parent_kind=n.kind) AS derivatives "
            "FROM nodes n WHERE n.dataset_id LIKE ? "
            "ORDER BY n.downloads DESC LIMIT 12", (f"%{q}%",)
        ).fetchall()
    else:
        rows = _con.execute(
            "SELECT n.dataset_id AS id, 'dataset' AS kind, n.downloads, "
            "(SELECT count(*) FROM edges WHERE parent=n.dataset_id) AS derivatives "
            "FROM nodes n WHERE n.dataset_id LIKE ? "
            "ORDER BY n.downloads DESC LIMIT 12", (f"%{q}%",)
        ).fetchall()
    return [dict(r) for r in rows]


@app.get("/api/search")
def api_search(q: str = Query(..., min_length=2, max_length=120)):
    """Substring search over the repos in the lineage graph."""
    return _search(q.strip())


@app.get("/stats")
def stats():
    return _stats()


@app.get("/examples")
def examples(n: int = 24):
    return _examples(n)


@app.get("/analysis")
def analysis():
    """Aggregate analysis of the inferred lineage graph."""
    return _analysis()


@app.get("/", response_class=HTMLResponse)
def index():
    return (INDEX_HTML
            .replace("__STATS__", json.dumps(_stats()))
            .replace("__EXAMPLES__", json.dumps(_examples(24)))
            .replace("__ANALYSIS__", json.dumps(_analysis())))


INDEX_HTML = """<!doctype html><html><head><meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1">
<title>Ecosystem Lineage Explorer</title>
<meta name="description" content="Explore inferred lineage across the Hugging Face Hub — which datasets and models are derived from which, recovered from content and declared tags.">
<meta property="og:title" content="Ecosystem Lineage Explorer">
<meta property="og:description" content="Hub datasets + models · inferred lineage edges recovered from content and declared tags. Search a repo to see its parents, children and siblings as an interactive graph.">
<meta property="og:type" content="website">
<meta name="twitter:card" content="summary">
<meta name="twitter:title" content="Ecosystem Lineage Explorer">
<meta name="twitter:description" content="Which Hugging Face datasets and models are derived from which — recovered from content and declared tags.">
<link rel="icon" href="data:image/svg+xml,<svg xmlns='http://www.w3.org/2000/svg' viewBox='0 0 100 100'><text y='.9em' font-size='90'>%F0%9F%8C%BF</text></svg>">
<script>/* set theme before paint: honour HF's ?__theme=, else fall back to prefers-color-scheme via CSS */
(function(){try{var t=new URLSearchParams(location.search).get('__theme');
 if(t==='dark'||t==='light')document.documentElement.setAttribute('data-theme',t);}catch(e){}})();</script>
<script src="https://unpkg.com/vis-network/standalone/umd/vis-network.min.js"></script>
<style>
:root{--paper:#fffff8;--ink:#111;--muted:#6f6f66;--rule:#dcdccf;--accent:#c1440e;--bar:#43586b;
 --hover:#f1f1e6;--code:#f1f1e6;--legend-bg:rgba(255,255,248,.94);--shadow:rgba(0,0,0,.12);
 --net-bg:#fffff8;--node:#43586b;--focus:#c1440e;--halo:#fffff8;--skel1:#efeee2}
/* Dark mode: honour HF's ?__theme=dark (data-theme) and OS preference; warm charcoal to keep the paper feel. */
@media (prefers-color-scheme:dark){:root:not([data-theme="light"]){
 --paper:#14140e;--ink:#e9e7da;--muted:#9b9a8b;--rule:#33332a;--accent:#e2703f;--bar:#7d93a8;
 --hover:#24241b;--code:#24241b;--legend-bg:rgba(20,20,14,.94);--shadow:rgba(0,0,0,.55);
 --net-bg:#14140e;--node:#7d93a8;--focus:#e2703f;--halo:#14140e;--skel1:#1f1f18}}
:root[data-theme="dark"]{
 --paper:#14140e;--ink:#e9e7da;--muted:#9b9a8b;--rule:#33332a;--accent:#e2703f;--bar:#7d93a8;
 --hover:#24241b;--code:#24241b;--legend-bg:rgba(20,20,14,.94);--shadow:rgba(0,0,0,.55);
 --net-bg:#14140e;--node:#7d93a8;--focus:#e2703f;--halo:#14140e;--skel1:#1f1f18}
*{box-sizing:border-box}
body{margin:0;background:var(--paper);color:var(--ink);
 font-family:Palatino,"Palatino Linotype","Book Antiqua",Georgia,serif;font-size:16px;line-height:1.5}
header{padding:22px 34px 14px;border-bottom:1px solid var(--rule)}
h1{font-weight:400;font-size:23px;margin:0;display:inline}
.sub{font-style:italic;color:var(--muted);font-size:14px;margin:3px 0 12px}
nav{display:flex;gap:18px;align-items:flex-end;flex-wrap:wrap}
nav .tab{font-size:15px;cursor:pointer;border-bottom:1px solid transparent;padding-bottom:2px}
nav .tab.on{border-color:var(--ink)}
.controls{display:flex;gap:18px;align-items:flex-end;margin-left:auto;flex-wrap:wrap}
label{display:block;font-size:11px;color:var(--muted);letter-spacing:.05em;margin-bottom:2px}
.acwrap{position:relative;display:inline-block}
#ac{position:absolute;top:100%;left:0;min-width:330px;background:var(--paper);
 border:1px solid var(--rule);box-shadow:0 3px 14px var(--shadow);z-index:50;
 max-height:330px;overflow-y:auto;display:none}
#ac .it{padding:5px 10px;cursor:pointer;font-size:13.5px;display:flex;gap:8px;align-items:baseline}
#ac .it small{color:var(--muted);margin-left:auto;font-size:11px;white-space:nowrap}
#ac .it:hover,#ac .it.sel{background:var(--hover)}
#ac .it b{font-weight:700;color:inherit}
input,select{font-family:inherit;font-size:15px;background:var(--paper);border:0;
 border-bottom:1px solid var(--ink);color:var(--ink);padding:3px 2px}
input{width:250px}
button{font-family:inherit;font-size:15px;background:none;border:0;color:var(--accent);
 border-bottom:1px solid var(--accent);cursor:pointer;padding:0 0 2px}
#overview{padding:26px 40px 60px;overflow:auto;height:calc(100vh - 132px)}
.grid{display:grid;grid-template-columns:repeat(auto-fit,minmax(360px,1fr));gap:34px 50px;max-width:1180px}
.fig h3{font-weight:400;font-size:13px;letter-spacing:.09em;text-transform:uppercase;color:var(--muted);
 margin:0 0 3px;border-bottom:1px solid var(--rule);padding-bottom:3px}
.cap{font-style:italic;color:var(--muted);font-size:12.5px;margin:0 0 9px}
table.bars{width:100%;border-collapse:collapse;font-size:14px}
table.bars td{padding:2.5px 6px;vertical-align:middle}
td.lbl{white-space:nowrap;max-width:230px;overflow:hidden;text-overflow:ellipsis}
td.bar{width:46%}
td.bar span{display:block;height:11px;background:var(--bar);opacity:.85}
td.num{text-align:right;color:var(--muted);font-variant-numeric:tabular-nums;width:48px}
#wrap{display:flex;height:calc(100vh - 132px);position:relative}
#net{flex:2.3;min-width:0;background:var(--net-bg)}
#legend{position:absolute;left:14px;bottom:14px;background:var(--legend-bg);
 border:1px solid var(--rule);padding:8px 11px;font-size:11px;line-height:1.75;max-width:210px;
 max-height:calc(100% - 28px);overflow-y:auto;user-select:none}
#legend .lkey{font-style:italic;color:var(--muted);margin-bottom:3px}
#legend .nk{white-space:nowrap;padding:1px 4px;color:var(--ink)}
#legend .gdot,#legend .gsq{display:inline-block;width:9px;height:9px;background:var(--node);
 margin-right:8px;vertical-align:middle}
#legend .gdot{border-radius:50%}
#legend .lt{white-space:nowrap;cursor:pointer;padding:1px 4px;margin:0 -4px;border-radius:3px}
#legend .lt:hover{background:var(--hover)}
#legend .lt.off{opacity:.35;text-decoration:line-through}
#legend .reset{margin-top:5px;padding-top:4px;border-top:1px solid var(--rule);
 font-style:italic;color:var(--muted);cursor:pointer}
#legend .reset:hover{color:var(--ink)}
#side{flex:1;max-width:440px;overflow:auto;padding:22px 28px;border-left:1px solid var(--rule)}
#side h2{font-weight:400;font-size:19px;margin:0;overflow-wrap:anywhere}
.meta{color:var(--muted);font-style:italic;font-size:13px;margin:4px 0}
#side h3{font-weight:400;font-size:12px;letter-spacing:.1em;text-transform:uppercase;color:var(--muted);
 margin:22px 0 7px;border-bottom:1px solid var(--rule);padding-bottom:3px}
.row{padding:4px 0;font-size:15px}
.dot{display:inline-block;width:8px;height:8px;border-radius:50%;margin-right:8px;vertical-align:middle}
.ty{font-style:italic;color:var(--muted);font-size:12.5px;margin-left:7px}
/* kind marker — a quiet typographic tag; datasets are the unmarked default, models are flagged */
.km{font-size:9.5px;letter-spacing:.06em;text-transform:uppercase;color:var(--muted);
 border:1px solid var(--rule);border-radius:2px;padding:0 3px;margin-right:6px;vertical-align:middle}
a{color:var(--ink);text-decoration:none;border-bottom:1px solid var(--rule);cursor:pointer}
a:hover{border-color:var(--ink)}
.meta a{border:0;color:var(--accent)}
a.hub{border:0;color:var(--accent);font-size:11px;margin-left:4px;padding:0 3px;opacity:.7}
a.hub:hover{opacity:1}
code{font-family:ui-monospace,monospace;font-size:12.5px;background:var(--code);padding:1px 5px}
.placeholder{color:var(--muted);font-style:italic}
.more{color:var(--muted);font-style:italic;font-size:12.5px;padding:5px 0 2px}
/* downstream-footprint: side-panel one-liner (muted labels, ink numbers) + table header row */
.impact{color:var(--muted);font-size:13px;margin:2px 0 6px;line-height:1.5}
.impact b{color:var(--ink);font-weight:400;font-variant-numeric:tabular-nums}
table.bars tr.hd td{font-size:10px;letter-spacing:.06em;text-transform:uppercase;color:var(--muted);
 border-bottom:1px solid var(--rule);padding-bottom:3px}
/* trending-enablement table: model row + its upward provenance chain */
.fig-wide{max-width:1180px;margin:0 0 34px}
.ksq{display:inline-block;width:8px;height:8px;background:var(--node);margin-right:7px;vertical-align:middle}
table.bars.trend td{padding:7px 6px;border-top:1px solid var(--rule)}
table.bars.trend tr:first-child td{border-top:0}
.trend-model{font-size:14.5px}
.trend-chain{color:var(--muted);font-size:12.5px;margin-top:3px;line-height:1.6}
.trend-chain a{color:var(--muted);border-bottom:1px solid var(--rule)}
.trend-chain a:hover{color:var(--ink);border-color:var(--ink)}
/* ---- Over time: cumulative line chart + edge-type sparkline small-multiples ---- */
.lc{display:block;max-width:820px}
.spark-row{display:grid;grid-template-columns:repeat(auto-fill,minmax(150px,1fr));gap:14px 22px;max-width:1000px;margin-top:4px}
.spark-lbl{font-size:12px;color:var(--ink);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
.spark-peak{font-size:10.5px;color:var(--muted);font-variant-numeric:tabular-nums;margin-top:1px}
/* ---- Explorer time-scrubber (thin strip under the graph) ---- */
#scrub{position:absolute;left:0;bottom:0;height:46px;background:var(--legend-bg);
 border-top:1px solid var(--rule);display:flex;align-items:center;gap:12px;padding:0 14px;
 font-size:11px;color:var(--muted);user-select:none;z-index:40}
#scrubPlay{font-family:inherit;font-size:14px;line-height:1;color:var(--accent);background:none;border:0;
 cursor:pointer;padding:2px 5px;flex:none}
#scrubTrack{position:relative;flex:1;height:4px;background:var(--rule);border-radius:2px;min-width:70px;
 touch-action:none}
#scrubFill{position:absolute;left:0;top:0;height:100%;background:var(--bar);opacity:.45;border-radius:2px;pointer-events:none}
.shandle{position:absolute;top:2px;width:13px;height:13px;margin:-7px 0 0 -6.5px;border-radius:50%;
 background:var(--paper);border:2px solid var(--bar);cursor:ew-resize;touch-action:none;box-shadow:0 1px 3px var(--shadow)}
#scrubEnd{border-color:var(--accent)}
#scrubMeta{flex:none;white-space:nowrap;font-variant-numeric:tabular-nums}
#scrubUndated{margin-left:9px;font-style:italic;opacity:.85}
#wrap.has-scrub #legend{bottom:58px}
@media(max-width:760px){#scrubUndated{display:none}#scrubMeta{font-size:10px}}
/* ---- Overview stat tiles (headline figures) ---- */
.tiles{display:grid;grid-template-columns:repeat(auto-fit,minmax(min(160px,100%),1fr));gap:1px;
 background:var(--rule);border-top:1px solid var(--rule);border-bottom:1px solid var(--rule);
 max-width:1180px;margin:0 0 42px}
.tile{background:var(--paper);padding:14px 20px 15px}
.tile:first-child{padding-left:0}
.tile .n{font-size:30px;line-height:1.05;font-variant-numeric:tabular-nums;letter-spacing:-.01em}
.tile .n .accent{color:var(--accent)}
.tile .k{font-size:11px;letter-spacing:.09em;text-transform:uppercase;color:var(--muted);margin-top:6px}
.tile .d{font-style:italic;font-size:12px;color:var(--muted);margin-top:2px}
/* ---- copy-link action ---- */
.act{cursor:pointer;color:var(--accent);border:0;background:none;font-family:inherit;font-size:13px;padding:0}
.act:hover{text-decoration:underline}
.act.ok{color:var(--muted);font-style:italic}
/* ---- loading skeleton ---- */
.skel-wrap{display:flex;flex-direction:column;gap:13px;padding:10px 2px}
.skel{height:11px;background:var(--skel1);animation:sk 1.9s ease-in-out infinite}
@media(prefers-reduced-motion:reduce){.skel{animation:none;opacity:.5}}
@keyframes sk{0%,100%{opacity:.3}50%{opacity:.65}}
.netload{position:absolute;inset:0;display:flex;align-items:center;justify-content:center;
 color:var(--muted);font-style:italic;font-size:14px;pointer-events:none}
.empty{color:var(--muted);padding:16px 0 6px;margin-top:6px;border-top:1px solid var(--rule)}
.empty .big{font-size:15px;color:var(--ink);font-style:normal;margin-bottom:4px}
/* ---- narrow screens: stop the analysis grid + controls overflowing ---- */
@media(max-width:640px){
 header{padding:16px 18px 12px}
 nav{gap:12px}
 .controls{margin-left:0;width:100%;gap:12px}
 .acwrap,.controls>span{display:block;flex:1 1 100%}
 #q,#ex{width:100%;max-width:100%}
 #overview{padding:20px 18px 48px;height:auto}
 .grid{grid-template-columns:1fr;gap:26px;max-width:100%}
 table.bars{table-layout:fixed}
 td.lbl{max-width:100%;overflow:hidden;text-overflow:ellipsis}
 /* stack the explorer: graph over side panel (vis-network needs an explicit height) */
 #wrap{flex-direction:column;height:auto}
 #net{flex:none;height:60vh}
 #side{max-width:100%;border-left:0;border-top:1px solid var(--rule)}
 /* pin the legend to the graph area (wrap is now height:auto, so its bottom anchor
    would strand the key below the whole side panel); cap to the graph height */
 #legend{top:14px;bottom:auto;max-height:calc(60vh - 28px)}
 /* same stranding fix for the scrubber: pin it to the bottom of the 60vh graph area */
 #scrub{top:calc(60vh - 46px);bottom:auto}
 /* when the scrubber is up, keep Daniel's pinned mobile legend clear of it */
 #wrap.has-scrub #legend{max-height:calc(60vh - 74px)}
 /* odd tile count in the 2-col wrap would expose the grid's rule background
    as an empty grey cell — let a lone last tile span the full row instead */
 .tile:last-child:nth-child(odd){grid-column:1/-1}
}
</style></head><body>
<header>
 <h1>Ecosystem Lineage Explorer</h1>
 <div class="sub" id="sub"></div>
 <nav>
  <span class="tab on" id="tabOv" onclick="showOverview()">Overview</span>
  <span class="tab" id="tabEx" onclick="showExplorer()">Explorer</span>
  <span class="controls">
   <span class="acwrap"><label>dataset or model</label><input id="q" placeholder="type to search… e.g. alpaca" spellcheck="false"
     autocomplete="off"><div id="ac"></div></span>
   <span><label>or a much-derived dataset</label>
    <select id="ex"><option value="">— examples —</option></select></span>
   <button onclick="explore()">explore →</button>
  </span>
 </nav>
</header>
<div id="overview"></div>
<div id="wrap" style="display:none"><div id="net"></div>
 <div id="netload" class="netload" style="display:none"><span id="netloadmsg">building graph…</span></div>
 <div id="legend"></div>
 <div id="scrub" style="display:none">
  <button id="scrubPlay" title="play the family's growth">▶</button>
  <div id="scrubTrack"><div id="scrubFill"></div>
   <div id="scrubStart" class="shandle" title="playback start — drag to start the sweep later"></div>
   <div id="scrubEnd" class="shandle" title="as of — drag to scrub the graph through time"></div></div>
  <div id="scrubMeta"><span id="scrubLabel"></span><span id="scrubUndated"></span></div>
 </div>
 <div id="side"></div></div>
<script>
const STATS=__STATS__, EXAMPLES=__EXAMPLES__, ANALYSIS=__ANALYSIS__;
const SEP='\\x1f';
document.getElementById('sub').textContent =
 'Inferred lineage across the Hugging Face Hub — which datasets and models are derived from which, recovered from content and declared tags.'
 +(STATS.built_at?'  · data as of '+STATS.built_at.slice(0,10):'');
const exSel=document.getElementById('ex');
for(const e of EXAMPLES){const o=document.createElement('option');o.value=e.id;
 o.dataset.kind=e.kind||'dataset';
 o.textContent=e.id+'  ('+e.derivatives+' derivatives)';exSel.appendChild(o);}
exSel.onchange=()=>{if(exSel.value){const o=exSel.selectedOptions[0];
 document.getElementById('q').value=exSel.value;pickedKind=(o&&o.dataset.kind)||'dataset';explore();}};
const COLORS={exact_copy:'#8a8a80',filtered_subset:'#4a6b8a',subset_modified:'#5a7a9a',
 subset_reformatted:'#39597a',cleaned:'#6a8a5a',regenerated_variant:'#b08a3e',
 modified_variant:'#9a8a6a',augmentation:'#7a6a9a',augmentation_modified:'#8a7aaa',
 translation:'#a8566a',reformat:'#4a8a8a',partial_overlap:'#aaaaa0',declared:'#c8c8b8',
 // model-lineage edge types (declared tags) — a distinct muted cluster (validated: adds
 // no worse adjacent-CVD confusion than the existing dataset-transform palette).
 trained_on:'#4b52a0',finetune:'#9c6849',adapter:'#7f884e',quantized:'#6f7c88',merge:'#96617f',
 aggregate:'#b8b8ac'};
// corner colour key — clickable filter (toggle type visibility). Model-lineage types
// are grouped under their own subhead; 'aggregate' is structural, not a filter row.
const LEGEND_TYPES=['exact_copy','filtered_subset','subset_modified','subset_reformatted','cleaned',
 'regenerated_variant','augmentation','augmentation_modified','translation','reformat','modified_variant',
 'partial_overlap','combined','declared',
 'trained_on','finetune','adapter','quantized','merge'];
const MODEL_TYPES=new Set(['trained_on','finetune','adapter','quantized','merge']);
const ACTIVE_TYPES=new Set(LEGEND_TYPES);
let currentNetwork=null;
// graph colours follow the active theme (light / dark) via the CSS variables
function themeVars(){const s=getComputedStyle(document.documentElement);
 const g=(k,f)=>(s.getPropertyValue(k).trim()||f);
 return {node:g('--node','#43586b'),focus:g('--focus','#c1440e'),
  halo:g('--halo','#fffff8'),ink:g('--ink','#111'),muted:g('--muted','#6f6f66')};}
// Hub URL: a dataset lives under /datasets/<id>, a model at the root /<id>.
function hubUrl(id,kind){return 'https://huggingface.co/'+(kind==='model'?'':'datasets/')+id;}
// node shape encodes kind: dot=dataset, square=model (colour stays reserved for meaning).
function kindStyle(kind){return {shape:kind==='model'?'square':'dot'};}
function esc(s){return String(s).replace(/[&<>"]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;','"':'&quot;'}[c]));}
// quiet kind marker: datasets are the unmarked default, models get a small tag.
function kindTag(kind){return kind==='model'?'<span class="km">model</span>':'';}
function showNetLoad(msg){const el=document.getElementById('netload');
 if(el){document.getElementById('netloadmsg').textContent=msg||'building graph…';el.style.display='flex';}}
function hideNetLoad(){const el=document.getElementById('netload');if(el)el.style.display='none';}
function copyLink(btn){const url=location.href;const done=()=>{btn.textContent='link copied ✓';
  btn.classList.add('ok');setTimeout(()=>{btn.textContent='copy link';btn.classList.remove('ok');},1600);};
 if(navigator.clipboard&&navigator.clipboard.writeText){navigator.clipboard.writeText(url).then(done).catch(fallback);}
 else fallback();
 function fallback(){const t=document.createElement('textarea');t.value=url;t.style.position='fixed';t.style.opacity=0;
  document.body.appendChild(t);t.select();try{document.execCommand('copy');done();}catch(e){}t.remove();}}
(function(){
 let h='<div class="lkey">node</div>'+
  '<div class="nk"><span class="gdot"></span>dataset</div>'+
  '<div class="nk"><span class="gsq"></span>model</div>'+
  '<div class="lkey" style="margin:6px 0 3px">relationship · click to narrow</div>';
 for(const t of LEGEND_TYPES){
  if(t==='trained_on')h+='<div class="lkey" style="margin:6px 0 3px">model lineage</div>';
  h+='<div class="lt" data-type="'+t+'"><span class="dot" style="background:'+(COLORS[t]||'#999')+'"></span>'+
   t.replace(/_/g,' ')+(t==='declared'?' (dashed)':'')+'</div>';
 }
 h+='<div class="reset" data-reset="1">show all</div>';
 document.getElementById('legend').innerHTML=h;})();
let filterMode=false;  // false=show-all default; flips after first click
let ASOF=null;  // time-scrubber "as of" timestamp (ms); null = show all, no time filtering
function applyFilter(){
 if(!currentNetwork)return;
 const edgesDS=currentNetwork.body.data.edges, nodesDS=currentNetwork.body.data.nodes;
 const allEdges=edgesDS.get();
 const typeOk=e=> e.__type==='aggregate'||ACTIVE_TYPES.has(e.__type);
 const timeOk=e=> ASOF===null||e.__t===undefined||e.__t<=ASOF;  // edge time = its child's creation
 edgesDS.update(allEdges.map(e=>({id:e.id, hidden:!(typeOk(e)&&timeOk(e))})));
 // "connected" ignores time, so a node created early appears at its OWN creation even before
 // its (later) edges draw — the map assembles node-by-node rather than only when links form.
 // Time then gates the node itself (undated always show; time hides even the focus, so
 // "as of t" reads as true growth). The type filter still narrows via this set.
 const connected=new Set();
 for(const e of allEdges) if(typeOk(e)){connected.add(e.from);connected.add(e.to);}
 const nTimeOk=n=> ASOF===null||n.__t===undefined||n.__t<=ASOF;
 nodesDS.update(nodesDS.get().map(n=>({id:n.id, hidden:!nTimeOk(n) || (!connected.has(n.id) && !n.__focus)})));
}
document.getElementById('legend').addEventListener('click',ev=>{
 const reset=ev.target.closest('[data-reset]');
 if(reset){LEGEND_TYPES.forEach(t=>ACTIVE_TYPES.add(t));
  document.querySelectorAll('#legend .lt').forEach(el=>el.classList.remove('off'));
  filterMode=false;applyFilter();return;}
 const lt=ev.target.closest('.lt');
 if(!lt||!lt.dataset.type)return;
 const t=lt.dataset.type;
 if(!filterMode){
  // first click → narrow to ONLY this type; subsequent clicks add more
  ACTIVE_TYPES.clear();ACTIVE_TYPES.add(t);
  document.querySelectorAll('#legend .lt').forEach(el=>el.classList.toggle('off', el.dataset.type!==t));
  filterMode=true;
 } else if(ACTIVE_TYPES.has(t)){
  // already in view → remove
  ACTIVE_TYPES.delete(t);lt.classList.add('off');
  if(ACTIVE_TYPES.size===0){
   // emptied → return to show-all
   LEGEND_TYPES.forEach(x=>ACTIVE_TYPES.add(x));
   document.querySelectorAll('#legend .lt').forEach(el=>el.classList.remove('off'));
   filterMode=false;
  }
 } else {
  // add to view
  ACTIVE_TYPES.add(t);lt.classList.remove('off');
 }
 applyFilter();
});

// ---------- Overview ----------
function bars(rows,opts){
 opts=opts||{};const max=Math.max(...rows.map(r=>r.n),1);let h='<table class="bars">';
 for(const r of rows){const w=Math.round(100*r.n/max);
  let lbl;
  if(opts.type){
   lbl='<span class="dot" style="background:'+(COLORS[r.t]||'#999')+'"></span>'+r.t.replace(/_/g,' ');
  } else {
   const isRepo=r.id.includes('/');const k=r.kind||'dataset';
   lbl=(isRepo?'<a data-ds="'+esc(r.id)+'" data-kind="'+k+'">'+esc(r.id)+'</a>':'<span>'+esc(r.id)+'</span>')+
    (isRepo?'<a class="hub" href="'+hubUrl(r.id,k)+'" target="_blank" rel="noopener" title="open on HF Hub">↗</a>':'');
  }
  const col=opts.type?(COLORS[r.t]||'#999'):'var(--bar)';
  h+='<tr><td class="lbl">'+lbl+'</td><td class="bar"><span style="width:'+w+'%;background:'+col+'"></span></td>'
   +'<td class="num">'+r.n.toLocaleString()+'</td></tr>';}
 return h+'</table>';
}
function fig(title,cap,body){return '<div class="fig"><h3>'+title+'</h3><div class="cap">'+cap+'</div>'+body+'</div>';}
// compact count: 3.2M / 740k / 512
function kfmt(n){n=n||0;
 if(n>=1e6)return (n/1e6).toFixed(n>=1e7?0:1).replace(/\\.0$/,'')+'M';
 if(n>=1e3)return Math.round(n/1e3)+'k';
 return ''+n;}
// downstream-footprint ruled table: dataset · descendant models · descendant downloads
function footprintTable(rows){
 let h='<table class="bars"><tr class="hd"><td class="lbl"></td><td class="num">models</td><td class="num">downloads</td></tr>';
 for(const r of rows){
  h+='<tr><td class="lbl"><a data-ds="'+esc(r.id)+'" data-kind="dataset">'+esc(r.id)+'</a>'+
   '<a class="hub" href="'+hubUrl(r.id,'dataset')+'" target="_blank" rel="noopener" title="open on HF Hub">↗</a></td>'+
   '<td class="num">'+(r.descendant_models||0).toLocaleString()+'</td>'+
   '<td class="num">'+kfmt(r.descendant_downloads)+'</td></tr>';}
 return h+'</table>';
}
// how each ancestry hop reads ("← finetune of X ← trained on Y")
const REL_PHRASE={finetune:'finetune of',adapter:'adapter of',quantized:'quantized from',
 merge:'merge of',trained_on:'trained on'};
function relPhrase(r){return REL_PHRASE[r]||(r?r.replace(/_/g,' '):'from');}
// trending models + their upward provenance chain; ids clickable into the explorer
function trendTable(rows){
 let h='<table class="bars trend">';
 for(const r of rows){
  const chain=(r.ancestry||[]).map(a=>'← '+relPhrase(a.rel)+
   ' <a data-ds="'+esc(a.id)+'" data-kind="'+(a.kind||'model')+'">'+esc(a.id.split('/').pop()||a.id)+'</a>').join(' ');
  h+='<tr><td><div class="trend-model"><span class="ksq"></span>'+
   '<a data-ds="'+esc(r.id)+'" data-kind="model">'+esc(r.id)+'</a>'+
   '<a class="hub" href="'+hubUrl(r.id,'model')+'" target="_blank" rel="noopener" title="open on HF Hub">↗</a></div>'+
   (chain?'<div class="trend-chain">'+chain+'</div>':'')+'</td></tr>';}
 return h+'</table>';
}
// ---------- Over time (SVG line chart + sparklines) ----------
function cumulative(a){let s=0;return (a||[]).map(v=>s+=(v||0));}
function fmtQ(p){const y=p.slice(0,4),mo=+p.slice(5,7);return y+' Q'+(Math.floor((mo-1)/3)+1);}
// cumulative line chart: thin lines, direct end-labels, recessive hairline axes,
// invisible per-point hit circles carry a native tooltip (the hover layer).
function lineChart(periods,series){
 const W=820,H=232,m={t:14,r:104,b:26,l:54},n=periods.length;
 const iw=W-m.l-m.r,ih=H-m.t-m.b;
 const maxv=Math.max(1,...series.flatMap(s=>s.values));
 const X=i=>m.l+(n<=1?iw/2:iw*i/(n-1)), Y=v=>m.t+ih*(1-v/maxv);
 let g='';
 for(const tv of [0,maxv/2,maxv]){const yy=Y(tv);
  g+='<line x1="'+m.l+'" y1="'+yy.toFixed(1)+'" x2="'+(W-m.r)+'" y2="'+yy.toFixed(1)+'" stroke="var(--rule)" stroke-width="1"/>'+
   '<text x="'+(m.l-8)+'" y="'+(yy+3.5).toFixed(1)+'" text-anchor="end" font-size="10" fill="var(--muted)" font-family="ui-monospace,monospace">'+kfmt(Math.round(tv))+'</text>';}
 let ly=null;
 periods.forEach((p,i)=>{const yr=p.slice(0,4);if(yr!==ly){ly=yr;
  g+='<text x="'+X(i).toFixed(1)+'" y="'+(H-8)+'" text-anchor="middle" font-size="10" fill="var(--muted)">'+yr+'</text>'+
   '<line x1="'+X(i).toFixed(1)+'" y1="'+(H-m.b)+'" x2="'+X(i).toFixed(1)+'" y2="'+(H-m.b+3)+'" stroke="var(--muted)" stroke-width="1"/>';}});
 for(const s of series){
  const d='M'+s.values.map((v,i)=>X(i).toFixed(1)+' '+Y(v).toFixed(1)).join(' L');
  g+='<path d="'+d+'" fill="none" stroke="'+s.color+'" stroke-width="2" stroke-linejoin="round" stroke-linecap="round"/>';
  const ex=X(n-1),ey=Y(s.values[n-1]);
  g+='<circle cx="'+ex.toFixed(1)+'" cy="'+ey.toFixed(1)+'" r="3.4" fill="'+s.color+'" stroke="var(--paper)" stroke-width="2"/>'+
   '<text x="'+(ex+7).toFixed(1)+'" y="'+(ey+4).toFixed(1)+'" font-size="12" fill="'+s.color+'">'+s.label+'</text>';
  for(let i=0;i<n;i++)g+='<circle cx="'+X(i).toFixed(1)+'" cy="'+Y(s.values[i]).toFixed(1)+'" r="9" fill="transparent"><title>'+fmtQ(periods[i])+' · '+s.label+' '+s.values[i].toLocaleString()+'</title></circle>';
 }
 return '<svg class="lc" viewBox="0 0 '+W+' '+H+'" preserveAspectRatio="xMidYMid meet" role="img" style="width:100%;height:auto">'+g+'</svg>';
}
function sparkline(values,color){
 const W=160,H=34,p=4,n=values.length,maxv=Math.max(1,...values);
 const X=i=>p+(n<=1?0:(W-2*p)*i/(n-1)), Y=v=>H-p-(H-2*p)*(v/maxv);
 const d='M'+values.map((v,i)=>X(i).toFixed(1)+' '+Y(v).toFixed(1)).join(' L');
 return '<svg viewBox="0 0 '+W+' '+H+'" preserveAspectRatio="none" style="display:block;width:100%;height:34px">'+
  '<path d="'+d+'" fill="none" stroke="'+color+'" stroke-width="1.4" vector-effect="non-scaling-stroke" stroke-linejoin="round"/></svg>';
}
function sparkRow(periods,edges){
 let h='<div class="spark-row">';
 for(const t of LEGEND_TYPES){const v=edges[t];if(!v||!v.some(x=>x))continue;
  h+='<div class="spark"><div class="spark-lbl"><span class="dot" style="background:'+(COLORS[t]||'#999')+'"></span>'+
   t.replace(/_/g,' ')+'</div>'+sparkline(v,COLORS[t]||'#999')+
   '<div class="spark-peak">peak '+kfmt(Math.max(...v))+'/q</div></div>';}
 return h+'</div>';
}
function statTiles(){
 // derivative-rate is scoped to datasets that appear in the inferred lineage
 // (not all dataset nodes, and never the model layer) so the % stays meaningful.
 const lineageDs=STATS.lineage_datasets||STATS.nodes;
 const pct=Math.round(100*STATS.derivatives/lineageDs);
 const T=(n,k,d)=>'<div class="tile"><div class="n">'+n+'</div><div class="k">'+k+'</div>'+
  (d?'<div class="d">'+d+'</div>':'')+'</div>';
 let t=
  T(lineageDs.toLocaleString(),'datasets in graph','with inferred lineage')+
  T(STATS.inferred.toLocaleString(),'inferred dataset edges','recovered from content')+
  T('<span class="accent">'+pct+'%</span>','of datasets are undeclared derivatives',
    STATS.derivatives.toLocaleString()+' of '+lineageDs.toLocaleString());
 // model layer — only when the db carries models; keeps the inferred (content) vs
 // declared (tags) provenance split visible at a glance.
 if(STATS.model_nodes)
  t+=T(STATS.model_nodes.toLocaleString(),'models linked',
    (STATS.declared_edges||0).toLocaleString()+' declared-tag edges');
 return '<div class="tiles">'+t+'</div>';
}
function showOverview(){
 hideScrub();
 document.getElementById('wrap').style.display='none';
 const ov=document.getElementById('overview');ov.style.display='block';
 document.getElementById('tabOv').classList.add('on');document.getElementById('tabEx').classList.remove('on');
 if(ov.dataset.done)return;
 const trend=(ANALYSIS.trending_enablement||[]);
 const tl=ANALYSIS.timeline;
 const overTime = (tl&&tl.periods&&tl.periods.length) ? (
  '<div class="fig fig-wide"><h3>How the graph grew</h3>'+
  '<div class="cap">Cumulative datasets and models with recovered lineage, by quarter of repo creation. The Hub only began stamping creation dates in March 2022, so the first point folds in every older repo.</div>'+
  lineChart(tl.periods,[
   {label:'datasets',color:'#4a6b8a',values:cumulative(tl.nodes.dataset)},
   {label:'models',color:'#9c6849',values:cumulative(tl.nodes.model)}])+'</div>'+
  '<div class="fig fig-wide"><h3>When each relationship type appeared</h3>'+
  '<div class="cap">New lineage edges per quarter, dated by the child\\'s creation — the finetune and quantization waves follow base-model releases.</div>'+
  sparkRow(tl.periods,tl.edges||{})+'</div>') : '';
 ov.innerHTML=statTiles()+overTime+
  (trend.length?'<div class="fig fig-wide">'+
   '<h3>Trending — and what enabled it</h3>'+
   '<div class="cap">The most-trending models on the Hub, each traced up its provenance to the base models and datasets that enabled it. Click any id to open it in the Explorer.</div>'+
   trendTable(trend)+'</div>':'')+
  '<div class="grid">'+
  fig('Relationship types','How '+STATS.inferred.toLocaleString()+' undeclared derivatives were made.',bars(ANALYSIS.type_dist,{type:1}))+
  fig('Most re-uploaded','Datasets with the most exact copies — redundant re-uploads on the Hub.',bars(ANALYSIS.most_copied))+
  fig('Most-derived datasets','The source datasets the community builds on most.',bars(ANALYSIS.most_derived))+
  fig('Most-translated','Datasets ported to the most other languages.',bars(ANALYSIS.most_translated))+
  fig('Most prolific producers','Orgs/users that publish the most derivative datasets.',bars(ANALYSIS.top_orgs))+
  ((ANALYSIS.downstream_footprint||[]).length?fig('Largest downstream model footprint',
    'Datasets whose trained-on models — direct plus their derivative closure — command the most downloads.',
    footprintTable(ANALYSIS.downstream_footprint)):'')+
  '</div><p class="cap" style="margin-top:26px;max-width:760px">Figures are over the analysed sample of high-popularity source datasets, not the whole Hub. Click any repo to open it in the Explorer.</p>';
 ov.dataset.done='1';
}

// ---------- search autocomplete ----------
const qEl=document.getElementById('q'), acEl=document.getElementById('ac');
let acItems=[], acSel=-1, acTimer=null, pickedKind='dataset';
function acHide(){acEl.style.display='none';acItems=[];acSel=-1;}
function acHi(id){const q=qEl.value.trim();const e=s=>s.replace(/[&<>]/g,c=>({'&':'&amp;','<':'&lt;','>':'&gt;'}[c]));
 if(!q)return e(id);const i=id.toLowerCase().indexOf(q.toLowerCase());if(i<0)return e(id);
 return e(id.slice(0,i))+'<b>'+e(id.slice(i,i+q.length))+'</b>'+e(id.slice(i+q.length));}
function acRender(){
 if(!acItems.length){acHide();return;}
 acEl.innerHTML=acItems.map((r,i)=>'<div class="it'+(i===acSel?' sel':'')+'" data-i="'+i+'">'+
  kindTag(r.kind)+acHi(r.id)+
  '<small>'+(r.derivatives?r.derivatives+' deriv · ':'')+(r.downloads||0).toLocaleString()+' dl</small></div>').join('');
 acEl.style.display='block';
}
qEl.addEventListener('input',()=>{
 clearTimeout(acTimer);pickedKind='dataset';const v=qEl.value.trim();
 if(v.length<2){acHide();return;}
 acTimer=setTimeout(async()=>{
  try{acItems=await fetch('/api/search?q='+encodeURIComponent(v)).then(x=>x.json());}
  catch(e){acItems=[];}
  acSel=-1;acRender();
 },150);
});
qEl.addEventListener('keydown',ev=>{
 if(ev.key==='ArrowDown'){acSel=Math.min(acSel+1,acItems.length-1);acRender();ev.preventDefault();}
 else if(ev.key==='ArrowUp'){acSel=Math.max(acSel-1,-1);acRender();ev.preventDefault();}
 else if(ev.key==='Enter'){
  if(acSel>=0&&acItems[acSel]){qEl.value=acItems[acSel].id;pickedKind=acItems[acSel].kind||'dataset';}
  acHide();explore();
 }
 else if(ev.key==='Escape')acHide();
});
acEl.addEventListener('mousedown',ev=>{const it=ev.target.closest('.it');
 if(it){const r=acItems[+it.dataset.i];qEl.value=r.id;pickedKind=r.kind||'dataset';acHide();explore();}});
document.addEventListener('click',ev=>{if(!ev.target.closest('.acwrap'))acHide();});

// ---------- Explorer ----------
let network;
function dot(t){return '<span class="dot" style="background:'+(COLORS[t]||'#999')+'"></span>';}
// hover a node -> spotlight its direct neighborhood, dim the rest
function enableHoverHighlight(net){
 const nodesDS=net.body.data.nodes, edgesDS=net.body.data.edges;
 net.on('hoverNode',p=>{
  const keepN=new Set([p.node,...net.getConnectedNodes(p.node)]);
  const keepE=new Set(net.getConnectedEdges(p.node));
  nodesDS.update(nodesDS.get().map(n=>({id:n.id,opacity:keepN.has(n.id)?1:.12})));
  edgesDS.update(edgesDS.get().map(e=>{
   if(e.__op===undefined)e.__op=(e.color&&e.color.opacity!==undefined)?e.color.opacity:1;
   return {id:e.id,__op:e.__op,color:{color:(e.color&&e.color.color)||COLORS[e.__type]||'#999',
    opacity:keepE.has(e.id)?Math.min(1,e.__op+.1):.06}};
  }));
 });
 net.on('blurNode',()=>{
  nodesDS.update(nodesDS.get().map(n=>({id:n.id,opacity:1})));
  edgesDS.update(edgesDS.get().map(e=>({id:e.id,
   color:{color:(e.color&&e.color.color)||COLORS[e.__type]||'#999',opacity:e.__op!==undefined?e.__op:1}})));
 });
}
// resolve a clicked vis node id -> {id,kind}; aggregate nodes are inert.
function openNode(net,nodeId){const n=net.body.data.nodes.get(nodeId);
 if(!n||n.__agg)return;
 if(n.__dsid)showExplorer(n.__dsid,n.__kind||'dataset');}
function explore(){const ds=document.getElementById('q').value.trim();if(ds)showExplorer(ds,pickedKind);}
function showExplorer(ds,kind,skipHistory){
 kind=kind||'dataset';
 document.getElementById('overview').style.display='none';
 document.getElementById('wrap').style.display='flex';
 document.getElementById('tabEx').classList.add('on');document.getElementById('tabOv').classList.remove('on');
 if(!skipHistory){
  const url=ds?('?dataset='+encodeURIComponent(ds)+(kind!=='dataset'?'&kind='+encodeURIComponent(kind):'')):'?view=map';
  history.pushState({ds:ds||null,kind:kind},'',url);
 }
 if(ds){document.getElementById('q').value=ds;currentKind=kind;go();}
 else{map();}  // default Explorer = overall map, zoom in by clicking
}
let currentKind='dataset';
window.addEventListener('popstate',ev=>{
 const ds=ev.state&&ev.state.ds;
 if(ev.state===null||(!ds&&!location.search.includes('view=map'))){showOverview();return;}
 showExplorer(ds||undefined,(ev.state&&ev.state.kind)||'dataset',true);
});
async function map(){
 const TV=themeVars();
 document.getElementById('side').innerHTML='<h2>Lineage map</h2>'+skel(5);
 showNetLoad('mapping lineage…');
 const g=await fetch('/api/map').then(x=>x.json());
 const caByKey={};g.nodes.forEach(n=>{caByKey[SEP+n.id]=parseT(n.created_at);});
 const nodes=g.nodes.map(n=>Object.assign({id:SEP+n.id,__dsid:n.id,__kind:n.kind||'dataset',
  __t:parseT(n.created_at),
  label:(n.derivatives>=8)?n.label:undefined,
  title:n.id+' · '+n.derivatives+' derivatives · '+(n.downloads||0).toLocaleString()+' downloads',
  size:6+Math.sqrt(n.derivatives||1)*2.4,
  color:{background:TV.node,border:TV.node},
  font:{color:TV.ink,face:'Palatino, Georgia, serif',size:13,strokeWidth:4,strokeColor:TV.halo}},
  kindStyle(n.kind||'dataset')));
 // edge time = its child's (=`to`) creation, per the family scrubber convention
 const edges=g.edges.map(e=>({from:SEP+e.from,to:SEP+e.to,__type:e.type,__t:caByKey[SEP+e.to],arrows:{to:{scaleFactor:.4}},
  color:{color:COLORS[e.type]||'#999',opacity:.9},width:1.6,title:e.type+' · '+e.confidence}));
 network=new vis.Network(document.getElementById('net'),{nodes,edges},
  {physics:{stabilization:{iterations:160,updateInterval:50},
    barnesHut:{gravitationalConstant:-14000,springLength:95,centralGravity:.12,avoidOverlap:.2}},
   nodes:{borderWidth:0},edges:{smooth:false},interaction:{hover:true,hideEdgesOnDrag:true,tooltipDelay:120}});
 network.on('stabilizationIterationsDone',()=>network.setOptions({physics:false}));
 network.once('afterDrawing',hideNetLoad);
 network.on('click',p=>{if(p.nodes.length)openNode(network,p.nodes[0]);});
 currentNetwork=network;buildScrub(g.nodes);applyFilter();enableHoverHighlight(network);
 document.getElementById('side').innerHTML='<h2>Lineage map</h2><div class="meta">'+
  g.nodes.length.toLocaleString()+' source datasets · '+g.edges.length+' multi-level chain links'+
  ' · <button class="act" onclick="copyLink(this)">copy link</button></div>'+
  '<p class="row">Node <b>size</b> = number of derivatives, <b>shape</b> = kind (● dataset, ▪ model). '+
  'Edge <b>colour</b> = relationship type (key, lower-left). '+
  'Large dots are heavily-reused datasets; connected runs are multi-step lineages. '+
  '<b>Click any node</b> to open its full lineage.</p>';
}
// build a vis node for an aggregate ("+K more") tail — a muted text annotation, inert.
function aggNode(n,TV){return {id:n.key,__agg:true,label:n.label,title:n.title,shape:'text',
  color:{color:TV.muted},
  font:{color:TV.muted,face:'Palatino, Georgia, serif',size:12,strokeWidth:4,strokeColor:TV.halo}};}
async function go(){
 const ds=document.getElementById('q').value.trim();if(!ds)return;
 const kind=currentKind||'dataset';
 const TV=themeVars();
 document.getElementById('side').innerHTML='<h2 style="overflow-wrap:anywhere">'+esc(ds)+'</h2>'+skel(6);
 showNetLoad('building lineage graph…');
 // shallower default on phones — depth-2 hairballs on a 375px canvas; desktop stays depth-2
 const depth = innerWidth < 640 ? 1 : 2;
 const [g,r]=await Promise.all([
  fetch('/api/graph?dataset='+encodeURIComponent(ds)+'&kind='+encodeURIComponent(kind)+'&depth='+depth).then(x=>x.json()),
  fetch('/related?dataset='+encodeURIComponent(ds)+'&kind='+encodeURIComponent(kind)).then(x=>x.json())]);
 const real=g.nodes.filter(n=>!n.agg);
 const top=new Set(real.slice().sort((a,b)=>(b.downloads||0)-(a.downloads||0)).slice(0,40).map(n=>n.key));
 const big=g.nodes.length>250;
 const f=g.nodes.find(n=>n.focus);const focusKey=f?f.key:(kind+SEP+ds);
 const tByKey={};g.nodes.forEach(n=>{tByKey[n.key]=parseT(n.created_at);});
 const nodes=g.nodes.map(n=>{
  if(n.agg)return aggNode(n,TV);
  return Object.assign({id:n.key,__dsid:n.id,__kind:n.kind,__focus:n.focus,__t:parseT(n.created_at),
   label:(n.focus||top.has(n.key)||!big)?n.label:undefined,title:n.title,
   size:n.focus?16:(6+Math.log10((n.downloads||0)+10)*2.2),
   color:{background:n.focus?TV.focus:TV.node,border:n.focus?TV.focus:TV.node},
   font:{color:TV.ink,face:'Palatino, Georgia, serif',size:n.focus?16:12,strokeWidth:4,strokeColor:TV.halo}},
   kindStyle(n.kind));
 });
 // edge time = its child's (=`to`) creation, per the spec
 const edges=g.edges.map(e=>{
  if(e.type==='aggregate')return {from:e.from,to:e.to,__type:'aggregate',__t:tByKey[e.to],arrows:{to:{scaleFactor:.35}},
   color:{color:COLORS.aggregate,opacity:.6},width:.6,dashes:[2,3]};
  return {from:e.from,to:e.to,__type:e.type,__t:tByKey[e.to],arrows:{to:{scaleFactor:.45}},
   color:{color:COLORS[e.type]||'#999',opacity:.8},width:e.source==='inferred'?1.2:.6,
   dashes:e.source==='declared',title:e.type+' · conf '+e.confidence+' · '+e.source};
 });
 // adaptive layout: hub-shaped (many children of focus) -> force (spreads radially);
 // chain-shaped (multi-level) -> hierarchical LR (reads as a tree).
 const fanout=g.edges.filter(e=>e.from===focusKey||e.to===focusKey).length;
 const useForce=fanout>25||g.nodes.length>180;
 const opts=useForce?{
  physics:{stabilization:{iterations:200,updateInterval:50},
   barnesHut:{gravitationalConstant:-12000,springLength:90,centralGravity:.05,
    avoidOverlap:.35,damping:.4}},
  nodes:{borderWidth:0},edges:{smooth:false,width:.6,color:{opacity:.55}},
  interaction:{hover:!big,tooltipDelay:120,hideEdgesOnDrag:true}}:{
  layout:{hierarchical:{enabled:true,direction:'LR',sortMethod:'directed',
   levelSeparation:230,nodeSpacing:16,treeSpacing:36,blockShifting:true,edgeMinimization:true}},
  physics:false,nodes:{borderWidth:0},edges:{smooth:false},
  interaction:{hover:!big,tooltipDelay:120,hideEdgesOnDrag:true}};
 network=new vis.Network(document.getElementById('net'),{nodes,edges},opts);
 if(useForce)network.on('stabilizationIterationsDone',()=>network.setOptions({physics:false}));
 network.once('afterDrawing',hideNetLoad);
 network.on('click',p=>{if(p.nodes.length)openNode(network,p.nodes[0]);});
 currentNetwork=network;buildScrub(g.nodes);applyFilter();enableHoverHighlight(network);
 renderSide(r);
}
function skel(n){let h='<div class="skel-wrap">';
 for(let i=0;i<n;i++)h+='<div class="skel" style="width:'+(58+((i*37)%38))+'%"></div>';
 return h+'</div>';}
const SIDE_CAP=60;  // side lists can be huge (a base model has 10k+ children); render a slice
function lst(title,arr){
 if(!arr||!arr.length)return '';
 let h='<h3>'+title+' · '+arr.length.toLocaleString()+'</h3>';
 for(const x of arr.slice(0,SIDE_CAP)){const t=x.primary_type||'';const k=x.kind||'dataset';
  h+='<div class="row">'+dot(t)+kindTag(k)+'<a data-ds="'+esc(x.id)+'" data-kind="'+k+'">'+esc(x.id)+'</a>'+
   '<a class="hub" href="'+hubUrl(x.id,k)+'" target="_blank" rel="noopener" title="open on HF Hub">↗</a>'+
   (t?'<span class="ty">'+t.replace(/_/g,' ')+(x.size_ratio?' ×'+x.size_ratio:'')+'</span>':'')+'</div>';}
 if(arr.length>SIDE_CAP)h+='<div class="more">+ '+(arr.length-SIDE_CAP).toLocaleString()+' more — full list via the query API below</div>';
 return h;
}
function renderSide(r){
 const m=r.meta||{};const kind=r.kind||'dataset';
 let h='<h2>'+esc(r.dataset)+'</h2><div class="meta">'+kindTag(kind)+(m.downloads||0).toLocaleString()+' downloads'+
  (m.author?' · '+esc(m.author):'')+' · <a href="'+hubUrl(r.dataset,kind)+'" target="_blank">Hub ↗</a>'+
  ' · <button class="act" onclick="copyLink(this)">copy link</button></div>';
 // downstream footprint — one typographic line, only when the db carries it
 if(r.impact){const im=r.impact;
  h+='<div class="impact">downstream · <b>'+(im.direct_models||0).toLocaleString()+'</b> models trained directly · <b>'+
   (im.descendant_models||0).toLocaleString()+'</b> incl. derivatives · <b>'+kfmt(im.descendant_downloads)+'</b> downloads</div>';}
 h+=lst('Derived from — parents',r.parents);
 h+=lst('Derivatives — children',r.children);
 h+=lst('Siblings — share a parent',r.siblings);
 if(!r.parents.length&&!r.children.length&&!r.siblings.length)
  h+='<div class="empty"><div class="big">No lineage recorded yet</div>'+
   'This repo has no parent, child, or sibling in the current analysed sample. '+
   'Lineage is inferred from content and declared tags, so newer or niche repos may not appear.</div>';
 h+='<h3>query API</h3><div class="row"><code>/related?dataset='+esc(r.dataset)+(kind!=='dataset'?'&kind='+kind:'')+'</code></div>';
 document.getElementById('side').innerHTML=h;
}
// any repo link anywhere -> open in explorer (carrying its kind)
document.addEventListener('click',e=>{const a=e.target.closest('a[data-ds]');
 if(a){e.preventDefault();showExplorer(a.getAttribute('data-ds'),a.getAttribute('data-kind')||'dataset');}});
// ---------- Explorer time-scrubber ----------
// A thin strip under the graph: END handle = "graph as of t" (client-side show/hide of
// already-loaded nodes/edges by created_at, no new API calls); START handle = where the
// ▶ sweep begins; undated nodes always show. Deep-linkable via &asof=YYYY-MM-DD.
function parseT(s){if(!s)return undefined;const t=Date.parse(s);return isNaN(t)?undefined:t;}
let TMIN=null,TMAX=null,PLAYFROM=null,playRAF=null,playTimer=null,playIdx=0,sortedT=[],INIT_ASOF=null;
const scrubEl=document.getElementById('scrub'),trackEl=document.getElementById('scrubTrack'),
 fillEl=document.getElementById('scrubFill'),hStart=document.getElementById('scrubStart'),
 hEnd=document.getElementById('scrubEnd'),labelEl=document.getElementById('scrubLabel'),
 undEl=document.getElementById('scrubUndated'),playBtn=document.getElementById('scrubPlay');
function fmtT(ms){return new Date(ms).toLocaleDateString(undefined,{year:'numeric',month:'short'});}
function cancelPlay(){if(playRAF){cancelAnimationFrame(playRAF);playRAF=null;}
 if(playTimer){clearTimeout(playTimer);playTimer=null;}playBtn.textContent='▶';}
function hideScrub(){cancelPlay();scrubEl.style.display='none';
 document.getElementById('wrap').classList.remove('has-scrub');ASOF=null;}
function buildScrub(gnodes){
 const real=gnodes.filter(n=>!n.agg);
 const ts=real.map(n=>parseT(n.created_at)).filter(t=>t!==undefined);
 const undated=real.length-ts.length;
 if(ts.length<2){hideScrub();return;}  // nothing meaningful to scrub through
 TMIN=Math.min(...ts);TMAX=Math.max(...ts);sortedT=[...new Set(ts)].sort((a,b)=>a-b);PLAYFROM=TMIN;
 ASOF=(INIT_ASOF!==null&&INIT_ASOF>=TMIN&&INIT_ASOF<TMAX)?INIT_ASOF:TMAX;
 INIT_ASOF=null;  // deep-link value is consumed once, on the first family
 undEl.textContent=undated?('· '+undated+' undated (always shown)'):'';
 scrubEl.style.display='flex';document.getElementById('wrap').classList.add('has-scrub');
 sizeScrub();setScrubUI();
}
function sizeScrub(){const net=document.getElementById('net');if(net)scrubEl.style.width=net.clientWidth+'px';}
function tToX(t){return (trackEl.clientWidth||1)*(t-TMIN)/((TMAX-TMIN)||1);}
function xToT(x){const f=Math.max(0,Math.min(1,x/(trackEl.clientWidth||1)));return TMIN+f*(TMAX-TMIN);}
function setScrubUI(){const xe=tToX(ASOF);hEnd.style.left=xe+'px';hStart.style.left=tToX(PLAYFROM)+'px';
 fillEl.style.width=xe+'px';labelEl.textContent='as of '+fmtT(ASOF);}
let _afLast=0,_afPend=null;
// throttled visibility update — the map carries ~1,700 nodes, so cap the vis-network
// DataSet updates to ~1 per 130ms during drag/play (a trailing call catches the last
// position). Build + commit still call applyFilter() immediately for an exact frame.
function applyFilterT(){const now=performance.now();
 if(now-_afLast>=130){_afLast=now;if(_afPend){clearTimeout(_afPend);_afPend=null;}applyFilter();}
 else if(!_afPend){_afPend=setTimeout(()=>{_afPend=null;_afLast=performance.now();applyFilter();},130-(now-_afLast));}}
function _afFlush(){if(_afPend){clearTimeout(_afPend);_afPend=null;}}
function setAsof(t,commit){ASOF=Math.max(TMIN,Math.min(TMAX,t));setScrubUI();
 if(commit){_afFlush();applyFilter();updateAsofUrl();}else applyFilterT();}
function updateAsofUrl(){const p=new URLSearchParams(location.search);
 if(ASOF!==null&&ASOF<TMAX-1)p.set('asof',new Date(ASOF).toISOString().slice(0,10));else p.delete('asof');
 try{history.replaceState(history.state,'','?'+p.toString());}catch(e){}}
function dragHandle(handle,onMove){handle.addEventListener('pointerdown',ev=>{
 ev.preventDefault();cancelPlay();try{handle.setPointerCapture(ev.pointerId);}catch(x){}
 const r=trackEl.getBoundingClientRect();
 const move=e=>onMove(xToT(e.clientX-r.left),false);
 const up=e=>{try{handle.releasePointerCapture(ev.pointerId);}catch(x){}
  handle.removeEventListener('pointermove',move);handle.removeEventListener('pointerup',up);
  onMove(xToT(e.clientX-r.left),true);};
 handle.addEventListener('pointermove',move);handle.addEventListener('pointerup',up);
 onMove(xToT(ev.clientX-r.left),false);});}
dragHandle(hEnd,(t,commit)=>setAsof(t,commit));
dragHandle(hStart,t=>{PLAYFROM=Math.max(TMIN,Math.min(TMAX,t));setScrubUI();});
function play(){
 if(playRAF||playTimer){cancelPlay();return;}   // toggle: already running -> stop
 const from=PLAYFROM,to=TMAX;
 if(!(to>from)){setAsof(to,true);return;}        // degenerate range -> just settle at the end
 playBtn.textContent='⏸';ASOF=from;setScrubUI();applyFilter();  // always restart from the play origin
 if(matchMedia('(prefers-reduced-motion:reduce)').matches){
  // reduced motion: non-animated but STILL functional — reveal in a few coarse steps
  const steps=6;let i=0;
  const tick=()=>{i++;ASOF=(i>=steps)?to:from+(to-from)*i/steps;setScrubUI();applyFilter();
   if(i>=steps){playTimer=null;playBtn.textContent='▶';updateAsofUrl();}else playTimer=setTimeout(tick,450);};
  playTimer=setTimeout(tick,450);return;
 }
 const dur=6000,t0=performance.now();
 const step=now=>{const f=Math.min(1,(now-t0)/dur);ASOF=from+f*(to-from);setScrubUI();applyFilterT();
  if(f<1)playRAF=requestAnimationFrame(step);
  else{playRAF=null;playBtn.textContent='▶';_afFlush();applyFilter();updateAsofUrl();}};
 playRAF=requestAnimationFrame(step);}
playBtn.addEventListener('click',play);
window.addEventListener('resize',()=>{if(scrubEl.style.display!=='none'){sizeScrub();setScrubUI();}});

// deep links: ?dataset=org/name(&kind=model)(&asof=YYYY-MM-DD) opens the explorer, ?view=map the map
const initParams=new URLSearchParams(location.search);
const initDs=initParams.get('dataset');
const initAsof=initParams.get('asof');if(initAsof){const t=Date.parse(initAsof);if(!isNaN(t))INIT_ASOF=t;}
if(initDs)showExplorer(initDs,initParams.get('kind')||'dataset',true);
else if(location.search.includes('view=map'))showExplorer(undefined,'dataset',true);
else showOverview();
</script></body></html>"""


if __name__ == "__main__":
    import uvicorn

    uvicorn.run(app, host="0.0.0.0", port=7860)