ripple-sql 0.1.4__tar.gz → 0.1.6__tar.gz

{ripple_sql-0.1.4 → ripple_sql-0.1.6}/CHANGELOG.md

@@ -6,6 +6,16 @@ Notable changes to Ripple. The format follows
 
 ## [Unreleased]
 
+## [0.1.6] - 2026-09-10
+
+### Fixed
+- Thirty-six findings from three rounds of a two-model review of the 0.1.3 to 0.1.5 work: the engine and map fixes each pinned by a test, the page fixes checked with headless browser probes (the page has no automated tests). Rounds two and three also settled INLINE over NULL and non-struct elements, name-matched fields, `AS (xx, yy)` alias lists, maps behind parentheses and casts, a cap before `as_native` parses, kind-prefixed group identities, the loader's own say on which folders are tables, and a cycle twin that stays visible while its other copy is folded. Engine: the generator names (`INLINE`, `EXPLODE`, `POSEXPLODE`) survive schema qualification, which reparsed the original SQL and threw them away; each `INLINE` output now takes lineage from its own struct field, not every field; `EXPLODE` over a map yields `key` and `value`; `as_number` keeps floats and `as_native` reads Python literals as dbt documents. Page: hovering a group heading threw instead of tinting (the group adjacency was walked as arrays); a group or model named `constructor` or `__proto__` crashed the page; a model's badge and a group's reader count included dashboard numbers while the key said models; a column suggestion showed its model's reader count instead of its own; two folders ending in the same name, or a schema and a folder of one name, merged into one row; a monorepo model named `models__marts__a` lost its folder; the filter went stale across focus and home and fought the fold; a late answer could overwrite newer navigation; Escape did not leave focus from the question box; a cycle drew a model on both sides; the typeahead left a stale `aria-activedescendant`.
+
+## [0.1.5] - 2026-09-09
+
+### Added
+- Every column under a model on the page carries the number of models that read it directly, the same number a model chip carries, so the cost of a change shows before the question is asked. A column no link touches (a constant, or one the engine could not trace) is drawn loose, dashed and faint, with "no link found" in the key; r/dataengineering asked for "a clear view of mapped vs unmapped fields (with some kind of legend)", and a traced-looking constant would have been a lie.
+
 ## [0.1.4] - 2026-09-09
 
 ### Changed
@@ -249,7 +259,9 @@ First public release.
 ### Removed
 - The dark whole-graph canvas that `ripple serve` used to open (`static/index.html`). Every surface now draws one answer.
 
-[Unreleased]: https://github.com/bteh/ripple/compare/v0.1.4...HEAD
+[Unreleased]: https://github.com/bteh/ripple/compare/v0.1.6...HEAD
+[0.1.6]: https://github.com/bteh/ripple/releases/tag/v0.1.6
+[0.1.5]: https://github.com/bteh/ripple/releases/tag/v0.1.5
 [0.1.4]: https://github.com/bteh/ripple/releases/tag/v0.1.4
 [0.1.3]: https://github.com/bteh/ripple/releases/tag/v0.1.3
 [0.1.2]: https://github.com/bteh/ripple/releases/tag/v0.1.2

{ripple_sql-0.1.4 → ripple_sql-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: ripple-sql
-Version: 0.1.4
+Version: 0.1.6
 Summary: Offline column-level SQL lineage. See what breaks before you merge.
 Project-URL: Homepage, https://github.com/bteh/ripple
 Project-URL: Repository, https://github.com/bteh/ripple

{ripple_sql-0.1.4 → ripple_sql-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "ripple-sql"
-version = "0.1.4"
+version = "0.1.6"
 description = "Offline column-level SQL lineage. See what breaks before you merge."
 readme = "README.md"
 requires-python = ">=3.10"

ripple_sql-0.1.6/src/ripple/engine/generators.py

@@ -0,0 +1,149 @@
+"""Bare table-generating functions name their own output columns.
+
+Spark's `SELECT INLINE(ARRAY(STRUCT('a' AS platform)))` has no alias and
+no column reference; its output columns are the struct's fields. A bare
+`EXPLODE(x)` is a column called `col`, `POSEXPLODE(x)` is `pos` and `col`,
+and over a map they are `key` and `value`. sqlglot leaves such items
+nameless, and the projection walks named them by their SQL text or dropped
+them, so a lookup table built this way reported no columns at all
+(Wikimedia dbt-jobs, platforms_ephemeral).
+
+The rewrite gives each output its default name as an alias over the
+expression that feeds it, before any projection walk runs: a struct field
+feeds its own output only, so a change to one field does not ripple to
+every column of the table.
+"""
+
+from __future__ import annotations
+
+from sqlglot import exp
+
+Output = tuple[str, exp.Expression]
+
+
+def generator_outputs(item: exp.Expression) -> list[Output] | None:
+    """(name, expression) per output column of a bare generator, None for
+    anything else. `INLINE(...) AS (xx, yy)` is the same generator with its
+    outputs named by position."""
+    if isinstance(item, exp.Aliases):
+        inner = generator_outputs(item.this)
+        names = [alias.name for alias in item.expressions]
+        if inner is None or len(names) != len(inner):
+            return None
+        return [(name, expr) for name, (_, expr) in zip(names, inner, strict=True)]
+    if isinstance(item, exp.Inline):
+        return _inline_outputs(item)
+    if isinstance(item, (exp.Explode, exp.Posexplode)):
+        return _explode_outputs(item)
+    return None
+
+
+def _struct_fields(element: exp.Expression) -> list[Output] | None:
+    if not isinstance(element, exp.Struct):
+        return None
+    fields: list[Output] = []
+    for field in element.expressions:
+        if isinstance(field, exp.PropertyEQ):
+            fields.append((field.this.name, field.expression))
+        elif isinstance(field, exp.Alias):
+            fields.append((field.alias, field.this))
+        elif isinstance(field, exp.Column):
+            fields.append((field.name, field))
+        else:
+            return None
+    return fields or None
+
+
+def _inline_outputs(item: exp.Inline) -> list[Output] | None:
+    """INLINE over a literal array: the first struct names the outputs and
+    field i of every struct feeds output i. That is Spark's own rule: the
+    array has one element type, and a later struct must carry the same
+    field names at the same positions, case-insensitively, or the query
+    fails analysis (TypeCoercion.findTypeForComplex). A struct whose names
+    are a permutation of the first's would not run in Spark; it is read by
+    name, as written. A NULL element adds nothing, and an element that is
+    not a struct literal (a struct column, a CASE) feeds every output, since
+    its fields cannot be told apart."""
+    array = item.this
+    if not (isinstance(array, exp.Array) and array.expressions):
+        return None
+    elements = [e for e in array.expressions if not isinstance(e, exp.Null)]
+    structs = [(e, _struct_fields(e)) for e in elements]
+    first = next((fields for _, fields in structs if fields), None)
+    if first is None:
+        return None
+    names = [name for name, _ in first]
+    feeds: list[list[exp.Expression]] = [[] for _ in names]
+    for element, fields in structs:
+        if fields is None:
+            for fed_by in feeds:
+                fed_by.append(element.copy())
+            continue
+        matched = _match_fields(first, fields)
+        if matched is None:
+            return None
+        for fed_by, expr in zip(feeds, matched, strict=True):
+            fed_by.append(expr.copy())
+    return [
+        (name, fed_by[0] if len(fed_by) == 1 else exp.Array(expressions=fed_by))
+        for name, fed_by in zip(names, feeds, strict=True)
+    ]
+
+
+def _match_fields(first: list[Output], fields: list[Output]) -> list[exp.Expression] | None:
+    """The expression of `fields` feeding each output of `first`, in order:
+    by position when the names line up (the only shape Spark accepts, and
+    the only reading when two unnamed fields share a name, `a.id, b.id`);
+    by name when they are a permutation; None when the shapes disagree."""
+    if len(fields) != len(first):
+        return None
+    want = [name.lower() for name, _ in first]
+    have = [name.lower() for name, _ in fields]
+    if want == have or len(set(have)) != len(have) or set(want) != set(have):
+        return [expr for _, expr in fields]
+    by_name = {name.lower(): expr for name, expr in fields}
+    return [by_name[name] for name in want]
+
+
+def _is_map(source: exp.Expression) -> bool:
+    if isinstance(source, (exp.Map, exp.VarMap)):
+        return True
+    to = source.args.get("to") if isinstance(source, exp.Cast) else None
+    return isinstance(to, exp.DataType) and to.this == exp.DataType.Type.MAP
+
+
+def _explode_outputs(item: exp.Expression) -> list[Output]:
+    """EXPLODE and POSEXPLODE: `col` fed by the whole call over an array;
+    `key` and `value` fed by the map's keys and values when the input is
+    visibly a map, or both by the whole map when only its type is visible
+    (a CAST to MAP). `pos` comes from the whole call either way."""
+    source = item.this
+    while isinstance(source, exp.Paren):
+        source = source.this
+    if isinstance(source, (exp.Map, exp.VarMap)):
+        outputs: list[Output] = [("key", source.args["keys"]), ("value", source.args["values"])]
+    elif _is_map(source):
+        outputs = [("key", source), ("value", source)]
+    else:
+        outputs = [("col", item)]
+    if isinstance(item, exp.Posexplode):
+        outputs = [("pos", item)] + outputs
+    return [(name, expr.copy()) for name, expr in outputs]
+
+
+def name_generator_outputs(tree: exp.Expression) -> exp.Expression:
+    """Alias every bare generator in every select list with its default
+    output names, in place, and return the tree."""
+    for select in list(tree.find_all(exp.Select)):
+        items = select.expressions
+        if not any(generator_outputs(item) for item in items):
+            continue
+        renamed: list[exp.Expression] = []
+        for item in items:
+            outputs = generator_outputs(item)
+            if not outputs:
+                renamed.append(item)
+                continue
+            renamed.extend(exp.alias_(expr, name) for name, expr in outputs)
+        select.set("expressions", renamed)
+    return tree

{ripple_sql-0.1.4 → ripple_sql-0.1.6}/src/ripple/engine/schema_qualification.py

@@ -92,9 +92,14 @@ def qualify_sql_with_schema(
     sql: str,
     dialect: str,
     warehouse_columns: WarehouseColumns,
+    expression: "exp.Expression | None" = None,
 ) -> tuple["exp.Expression | None", bool]:
     """Qualify unqualified columns in SQL using warehouse schema.
 
+    Pass `expression` when the caller has already normalized the tree (bare
+    generators named, for one): re-parsing the text here would throw that
+    work away, and the caller's names would come back as _col_0.
+
     Uses SQLGlot's optimizer.qualify to add table qualifiers to columns.
     This resolves ambiguous column references like SELECT col FROM a, b
     into SELECT a.col FROM a, b when 'col' only exists in table 'a'.
@@ -120,8 +125,13 @@ def qualify_sql_with_schema(
         return None, False
 
     schema_dict = build_sqlglot_schema(warehouse_columns)
+
+    def fresh() -> "exp.Expression":
+        # qualify() mutates, so each attempt starts from its own copy
+        return expression.copy() if expression is not None else sqlglot.parse_one(sql, read=dialect)
+
     try:
-        parsed = sqlglot.parse_one(sql, read=dialect)
+        parsed = fresh()
         qualified = qualify(parsed, schema=schema_dict, dialect=dialect)
         return qualified, True
     except Exception as e:
@@ -130,7 +140,7 @@ def qualify_sql_with_schema(
     # what the schema resolves, leave the rest as written instead of throwing
     # away every resolved column with it.
     try:
-        parsed = sqlglot.parse_one(sql, read=dialect)
+        parsed = fresh()
         qualified = qualify(
             parsed,
             schema=schema_dict,

{ripple_sql-0.1.4 → ripple_sql-0.1.6}/src/ripple/engine/statement.py

@@ -247,7 +247,7 @@ def extract_column_lineage_fast(
         # return the AST directly to avoid double-parsing
         if warehouse_columns:
             qualified_ast, was_qualified = qualify_sql_with_schema(
-                cleaned_sql, dialect, warehouse_columns
+                cleaned_sql, dialect, warehouse_columns, expression=parsed
             )
             if was_qualified and qualified_ast is not None:
                 parsed = qualified_ast

{ripple_sql-0.1.4 → ripple_sql-0.1.6}/src/ripple/home.py

@@ -115,6 +115,9 @@ def model_map(nodes: list[dict], edges) -> dict:
     it, a dashboard number past a dashboard prefix, and a model otherwise.
     Star and placeholder columns are links, never columns."""
     members: dict[str, dict] = {}
+    # the loader's identity says whether a folder is the table; kept aside so
+    # the page payload does not carry it
+    uids = {n["name"]: n.get("id") or "" for n in nodes}
     for n in nodes:
         source = n["type"] == "source"
         columns = [c for c in n.get("columns") or [] if _is_column(c)]
@@ -130,10 +133,19 @@ def model_map(nodes: list[dict], edges) -> dict:
         }
     fed = {e.dst_model for e in edges}
     seen: dict[str, dict[str, None]] = {}
+    readers: dict[tuple[str, str], set[str]] = {}
+    linked: set[tuple[str, str]] = set()
     for e in edges:
         for model, column in ((e.src_model, e.src_column), (e.dst_model, e.dst_column)):
             if _is_column(column):
                 seen.setdefault(model, {})[column] = None
+        if e.kind != "value" or not (_is_column(e.src_column) and _is_column(e.dst_column)):
+            continue
+        linked.add((e.src_model, e.src_column))
+        linked.add((e.dst_model, e.dst_column))
+        # a dashboard number is not a reader; only models count (as in starters)
+        if not e.dst_model.startswith(DASHBOARD_PREFIXES):
+            readers.setdefault((e.src_model, e.src_column), set()).add(e.dst_model)
     for name in sorted({e.src_model for e in edges} | fed):
         if name in members:
             known = members[name]["columns"]
@@ -151,22 +163,33 @@ def model_map(nodes: list[dict], edges) -> dict:
             "status": None,
             "path": None,
         }
+    for m in members.values():
+        # per column, aligned with `columns`: how many models read it directly;
+        # -1 when no link touches it at all (a constant, or one the engine
+        # could not trace), so the page never draws such a column as traced
+        m["reads"] = [
+            len(readers.get((m["id"], c), ())) if (m["id"], c) in linked else -1
+            for c in m["columns"]
+        ]
     links = _links(edges)
     layers = _layers(members, links)
     models = [{**m, "layer": layers[m["id"]]} for m in members.values()]
-    _name_groups(models)
+    labels = _name_groups(models, uids)
     ordered = _ordered(models, links)
-    return {"models": ordered, "links": links, "groups": _groups(ordered, links)}
+    return {"models": ordered, "links": links, "groups": _groups(ordered, links, labels)}
 
 
-def group_of(member: dict) -> str:
-    """Where a model lives, as a person would say it: the folder of a model,
-    the schema of a source table, "dashboards" for a dashboard number.
+def group_of(member: dict, uid: str = "", table_folders: frozenset[str] = frozenset()) -> str:
+    """Where a model lives, unshortened: the folder of a model, the schema of
+    a source table, "dashboards" for a dashboard number.
 
-    A file named after its model sits in its folder (`models/marts/orders.sql`
-    is in `models/marts`). A file with a generic name names its folder as the
-    table (`telemetry_derived/clients_v1/query.sql`), so the group is the
-    folder above. A model with no path is in "models"."""
+    A model file sits in its folder (`models/marts/orders.sql` is in
+    `models/marts`), whatever the model is called: a monorepo may name it
+    `models__marts__orders`, and a dbt model may be called query. When the
+    loader itself took a folder as the table (`telemetry_derived/clients_v1/
+    query.sql`, a schema.yaml sidecar) the group is the folder above, for
+    that model and for every other file in the table's folder (a script.sql
+    beside the query). A model with no path is in "models"."""
     if member["kind"] == "dashboard":
         return "dashboards"
     if member["kind"] == "source":
@@ -175,55 +198,95 @@ def group_of(member: dict) -> str:
     path = member.get("path")
     if not path:
         return "models"
-    parts = path.replace("\\", "/").split("/")
-    stem = parts[-1].rsplit(".", 1)[0]
-    folders = parts[:-1]
-    if folders and stem != member["id"]:
+    folders = path.replace("\\", "/").split("/")[:-1]
+    if table_folder(member, uid) or "/".join(folders).lower() in table_folders:
         folders = folders[:-1]
     return "/".join(folders) or "models"
 
 
+def table_folder(member: dict, uid: str = "") -> str | None:
+    """The folder a model's loader took as the table, lowercased, or None.
+
+    That happened when the model's name, or the relation in its uid
+    (path::relation, possibly dataset.table), is the last folder and the
+    file is called something else (query.sql, schema.yaml). A file that is
+    the folder's namesake, or any file in a dbt project, keeps its folder."""
+    path = member.get("path")
+    if not path or member["kind"] != "model":
+        return None
+    parts = path.replace("\\", "/").split("/")
+    folders, stem = parts[:-1], parts[-1].rsplit(".", 1)[0]
+    if not folders:
+        return None
+    folder = folders[-1].lower()
+    relation = uid.rpartition("::")[-1].rpartition(".")[-1].lower()
+    name = member["id"].lower()
+    named_after_folder = folder in (name, relation) or name.endswith("__" + folder)
+    if named_after_folder and stem.lower() != folder:
+        return "/".join(folders).lower()
+    return None
+
+
 def _shorten(names: set[str], sep: str) -> dict[str, str]:
-    """Drop the leading segments every name shares, so `models/staging` and
-    `models/marts` read as `staging` and `marts`. A lone name keeps itself."""
+    """Labels: drop the leading segments every deep name shares, so
+    `models/staging` and `models/marts` read as `staging` and `marts`. A lone
+    name keeps itself, and `models/core` next to `models/staging/core` keeps
+    enough to tell them apart."""
     parts = {n: n.split(sep) for n in names}
     while True:
         deep = [p for p in parts.values() if len(p) > 1]
         if len(deep) < 2 or len({p[0] for p in deep}) != 1:
             break
-        parts = {n: p[1:] if len(p) > 1 else p for n, p in parts.items()}
+        nxt = {n: p[1:] if len(p) > 1 else p for n, p in parts.items()}
+        # a strip that makes two names read the same stops here
+        if len({sep.join(p) for p in nxt.values()}) < len(nxt):
+            break
+        parts = nxt
     return {n: sep.join(p) for n, p in parts.items()}
 
 
 SOURCE_SCHEMAS = 6
 
 
-def _name_groups(models: list[dict]) -> None:
-    """Set each model's group, shortened per kind, in place. A project that
-    reads from more than a handful of schemas gets one "sources" group: a
-    row per schema would be a page of one-table rows, and the chip already
-    carries the schema in its name."""
-    raw = {m["id"]: group_of(m) for m in models}
-    short: dict[str, str] = {}
-    for kind, sep in (("model", "/"), ("source", ".")):
+def _name_groups(models: list[dict], uids: dict[str, str]) -> dict[str, str]:
+    """Set each model's group in place and return the label of every group.
+
+    The group is an identity, never shown: the kind and the unshortened
+    folder or schema (`model:models/marts`, `source:raw`), so a schema and a
+    folder of one name, or a folder called dashboards, stay separate rows.
+    The label is what the page prints. A project that reads
+    from more than a handful of schemas gets one "sources" group: a row per
+    schema would be a page of one-table rows, and the chip already carries
+    the schema in its name."""
+    tables = frozenset(t for m in models if (t := table_folder(m, uids.get(m["id"], ""))))
+    raw = {m["id"]: group_of(m, uids.get(m["id"], ""), tables) for m in models}
+    labels: dict[str, str] = {}
+    for kind, sep in (("model", "/"), ("source", "."), ("dashboard", "/")):
+        prefix = kind + ":"
         names = {raw[m["id"]] for m in models if m["kind"] == kind}
         if kind == "source" and len(names) > SOURCE_SCHEMAS:
-            short.update({n: "sources" for n in names})
-            continue
-        short.update(_shorten(names, sep))
+            for m in models:
+                if m["kind"] == kind:
+                    raw[m["id"]] = "sources"
+            names = {"sources"}
+        for name, label in _shorten(names, sep).items():
+            labels[prefix + name] = label
     for m in models:
-        m["group"] = short.get(raw[m["id"]], raw[m["id"]])
+        m["group"] = m["kind"] + ":" + raw[m["id"]]
+    return labels
 
 
 GROUP_RANK = {"source": 0, "model": 1, "dashboard": 2}
 
 
-def _groups(models: list[dict], links: list[dict]) -> list[dict]:
+def _groups(models: list[dict], links: list[dict], labels: dict[str, str]) -> list[dict]:
     """The groups in the order the data flows: source schemas, then model
     folders by the mean layer of their models, then dashboards. Each carries
-    how many models it holds and how many models outside it read one of its."""
+    its label, how many models it holds and how many models outside it read
+    one of its; a dashboard number is not a reader."""
     by: dict[str, dict] = {}
     of: dict[str, str] = {}
+    kind_of: dict[str, str] = {}
     for m in models:
         g = by.setdefault(
             m["group"],
@@ -231,19 +294,25 @@ def _groups(models: list[dict], links: list[dict]) -> list[dict]:
         )
         g["n"] += 1
         g["layers"].append(m["layer"])
-        if GROUP_RANK[m["kind"]] > GROUP_RANK[g["kind"]]:
-            g["kind"] = m["kind"]
         of[m["id"]] = m["group"]
+        kind_of[m["id"]] = m["kind"]
     for link in links:
         src, dst = of.get(link["src"]), of.get(link["dst"])
-        if src and dst and src != dst:
+        if src and dst and src != dst and kind_of[link["dst"]] != "dashboard":
             by[src]["readers"].add(link["dst"])
     out = sorted(
         by.values(),
         key=lambda g: (GROUP_RANK[g["kind"]], sum(g["layers"]) / len(g["layers"]), g["id"]),
     )
     return [
-        {"id": g["id"], "kind": g["kind"], "n": g["n"], "readers": len(g["readers"])} for g in out
+        {
+            "id": g["id"],
+            "label": labels.get(g["id"], g["id"]),
+            "kind": g["kind"],
+            "n": g["n"],
+            "readers": len(g["readers"]),
+        }
+        for g in out
     ]
 
 

{ripple_sql-0.1.4 → ripple_sql-0.1.6}/src/ripple/render.py

@@ -18,6 +18,7 @@ matters; unknown macros degrade to NULL (parseable, no fake lineage).
 
 from __future__ import annotations
 
+import ast as _ast
 import datetime as _datetime
 import itertools as _itertools
 import re
@@ -288,25 +289,35 @@ def _as_bool(value):
 
 
 def _as_number(value):
+    """dbt's as_number: a number stays what it is (1.5 is not 1), a string
+    becomes an int or a float, anything else comes back untouched."""
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return value
+    text = str(value).strip()
     try:
-        return int(value)
-    except (TypeError, ValueError):
+        return int(text)
+    except ValueError:
         pass
     try:
-        return float(value)
-    except (TypeError, ValueError):
+        return float(text)
+    except ValueError:
         return value
 
 
+# a literal past this length never reaches the parser: deep enough nesting
+# can overflow the C parser outright, past any except clause, and no dbt
+# var is a tenth of it
+_LITERAL_MAX = 10_000
+
+
 def _as_native(value):
-    """dbt's as_native: a string read back as YAML, anything else untouched."""
-    if not isinstance(value, str):
+    """dbt's as_native: a string read as a Python literal (a tuple, a dict
+    with None in it), the string itself when it is not one."""
+    if not isinstance(value, str) or len(value) > _LITERAL_MAX:
         return value
     try:
-        import yaml
-
-        return yaml.safe_load(value)
-    except Exception:
+        return _ast.literal_eval(value.strip())
+    except (ValueError, SyntaxError, TypeError, MemoryError, RecursionError):
         return value
 
 

{ripple_sql-0.1.4 → ripple_sql-0.1.6}/src/ripple/static/answer.css

@@ -77,6 +77,7 @@ h1 code{font:500 24px/1 var(--mono); letter-spacing:0}
 .key i.r{border-top-style:dashed; border-color:var(--review)}
 .key s{display:inline-block; width:11px; height:11px; border-radius:2px; background:var(--ink); border:1px solid var(--ink); text-decoration:none}
 .key s.src{background:var(--well); border:1px dashed var(--line-strong)}
+.key s.unk{background:transparent; border:1px dashed var(--faint)}
 .key small.n{font:400 11.5px/1 var(--sans); color:var(--faint); border:1px solid var(--line-strong); border-radius:var(--r); padding:2px 5px; background:var(--surface)}
 .hint{margin-left:auto; font-size:12.5px; color:var(--faint)}
 .rows{padding:0 22px 14px; font-size:13.5px; color:var(--muted)}
@@ -110,6 +111,9 @@ pre{margin:0; padding:16px 22px 18px; overflow-x:auto; font:400 13px/1.65 var(--
 .cols{display:flex; flex-direction:column; gap:5px; margin:0 0 6px 10px; padding-left:10px; border-left:1px solid var(--line)}
 .cols .gname{max-width:36ch; white-space:normal; line-height:1.45; padding-top:2px}
 .cols .node{cursor:pointer}
+.cols .node small{font:400 11px/1 var(--sans); color:var(--faint); margin-left:5px}
+.cols .node.unk{color:var(--muted)}
+.cols .node.unk:hover{border-color:var(--accent)}
 .cols .node:hover{border-color:var(--accent); color:var(--accent-strong)}
 .more-chips{font:500 12.5px var(--sans); color:var(--accent); background:none; border:0; padding:4px 0; cursor:pointer; text-align:left}
 .more-chips:hover{text-decoration:underline}
@@ -140,8 +144,8 @@ pre{margin:0; padding:16px 22px 18px; overflow-x:auto; font:400 13px/1.65 var(--
 .gcell:hover{background:var(--well)}
 .grow.sel .gcell{background:var(--accent); color:#fff}
 .grow.sel .gcell small{color:rgba(255,255,255,.72)}
-.grow.up .gcell{background:#E4F1F4; box-shadow:inset 3px 0 0 var(--accent)}
-.grow.down .gcell{background:var(--well); box-shadow:inset 3px 0 0 var(--ink)}
+.grow.up .gcell{background:#E4F1F4; color:var(--accent-strong)}
+.grow.down .gcell{background:var(--well)}
 .index .chips{display:flex; flex-wrap:wrap; gap:6px 8px; align-items:center}
 .index .mdl{max-width:100%; overflow-wrap:anywhere; text-align:left; line-height:1.25}
 .index .gname{flex-basis:100%}