feat(web): render rel-typed edges dashed with predicate

Author: ontehfritz

internal/adapter/inbound/web/graph.go

@@ -44,8 +44,10 @@ const arrowMarker = `<defs><marker id="arrow" markerWidth="9" markerHeight="9" r
 // pointing at the target, trimmed back by each endpoint's node radius so the
 // line sits between the rims and the arrowhead lands just outside the target
 // node instead of hiding under it. fromID/toID tag the edge with its endpoint
-// node ids so a node-hover handler can light up every incident edge.
-func directedEdge(b *strings.Builder, x1, y1, r1, x2, y2, r2 int, fromID, toID string) {
+// node ids so a node-hover handler can light up every incident edge. A
+// non-empty rel (a typed relation's predicate) draws dashed with the
+// predicate as its hover tooltip; "" is a plain reference.
+func directedEdge(b *strings.Builder, x1, y1, r1, x2, y2, r2 int, fromID, toID, rel string) {
 	dx, dy := float64(x2-x1), float64(y2-y1)
 	d := math.Hypot(dx, dy)
 	if d == 0 {
@@ -55,8 +57,13 @@ func directedEdge(b *strings.Builder, x1, y1, r1, x2, y2, r2 int, fromID, toID s
 	const gap = 3.0 // breathing room between arrow tip and target rim
 	sx, sy := x1+int(ux*float64(r1)), y1+int(uy*float64(r1))
 	ex, ey := x2-int(ux*(float64(r2)+gap)), y2-int(uy*(float64(r2)+gap))
-	fmt.Fprintf(b, `<line class="graph-edge" x1="%d" y1="%d" x2="%d" y2="%d" data-from="%s" data-to="%s" marker-end="url(#arrow)"/>`,
-		sx, sy, ex, ey, html.EscapeString(fromID), html.EscapeString(toID))
+	if rel == "" {
+		fmt.Fprintf(b, `<line class="graph-edge" x1="%d" y1="%d" x2="%d" y2="%d" data-from="%s" data-to="%s" marker-end="url(#arrow)"/>`,
+			sx, sy, ex, ey, html.EscapeString(fromID), html.EscapeString(toID))
+		return
+	}
+	fmt.Fprintf(b, `<line class="graph-edge edge-rel" x1="%d" y1="%d" x2="%d" y2="%d" data-from="%s" data-to="%s" marker-end="url(#arrow)"><title>%s</title></line>`,
+		sx, sy, ex, ey, html.EscapeString(fromID), html.EscapeString(toID), html.EscapeString(rel))
 }
 
 // GraphPage renders the graph neighborhood as a standalone permalink —
@@ -149,9 +156,9 @@ func graphSVG(n domain.Neighborhood, urlFor func(domain.Ref) string, onTrail map
 	// outbound link points center→neighbor, a backlink points neighbor→center.
 	for _, pn := range placed {
 		if pn.inbound {
-			directedEdge(&b, pn.x, pn.y, graphNodeR, cx, cy, graphCenterR, pn.ref.Path, n.Center.Path)
+			directedEdge(&b, pn.x, pn.y, graphNodeR, cx, cy, graphCenterR, pn.ref.Path, n.Center.Path, "")
 		} else {
-			directedEdge(&b, cx, cy, graphCenterR, pn.x, pn.y, graphNodeR, n.Center.Path, pn.ref.Path)
+			directedEdge(&b, cx, cy, graphCenterR, pn.x, pn.y, graphNodeR, n.Center.Path, pn.ref.Path, "")
 		}
 	}
 	// Center node (data-node so hovering it lights up all its edges).

internal/adapter/inbound/web/templates/page.html

@@ -327,6 +327,9 @@
     svg.graph { max-width: 100%; height: auto; }
     svg.graph text { fill: var(--muted); font-family: system-ui, sans-serif; }
     .graph-edge { stroke: var(--faint); stroke-width: 1.5; }
+    /* A typed relation (rel-<predicate>) draws dashed; its predicate is the
+       <title> tooltip on the line. */
+    .graph-edge.edge-rel { stroke-dasharray: 5 3; }
     .edge-arrow { fill: var(--muted); }
     /* Node hover (islands.js) lights up the incident edges and the nodes they
        connect, so the relationship reads. */

internal/adapter/inbound/web/worldmap.go

@@ -295,7 +295,7 @@ func worldMapSVG(wm domain.WorldMap, docURL func(string) string, newURL string)
 		if !okF || !okT {
 			continue
 		}
-		directedEdge(&b, from.x, from.y, from.r, to.x, to.y, to.r, e.From.Path, e.To.Path)
+		directedEdge(&b, from.x, from.y, from.r, to.x, to.y, to.r, e.From.Path, e.To.Path, e.Rel)
 	}
 	for _, d := range linked {
 		pn := placed[d.Path]

internal/adapter/inbound/web/worldmap_test.go

@@ -186,3 +186,19 @@ func TestTrailWorldMapErrorHandling(t *testing.T) {
 		t.Errorf("unfocused world-map error must tombstone: %d", rec.Code)
 	}
 }
+
+// A rel-typed edge draws dashed (edge-rel) with its predicate as the tooltip;
+// plain edges stay untouched.
+func TestWorldMapSVGRelEdge(t *testing.T) {
+	wm := testWorldMap()
+	wm.Edges[0].Rel = "supersedes"
+	svg := string(worldMapSVG(wm, func(p string) string { return p }, ""))
+	for _, want := range []string{
+		`class="graph-edge edge-rel"`,
+		`<title>supersedes</title>`,
+	} {
+		if !strings.Contains(svg, want) {
+			t.Errorf("world-map svg missing %q\n---\n%s", want, svg)
+		}
+	}
+}

internal/adapter/outbound/graphexport/graphexport.go

@@ -16,8 +16,9 @@ import (
 type Parser struct{}
 
 // ParseGraphExport decodes body into domain nodes and reference edges:
-// mark:// endpoints only, and one edge per document pair (enriched exports
-// repeat a pair with rel-typed rows).
+// mark:// endpoints only, and one edge per document pair. Enriched exports
+// repeat a pair as a plain plus rel-typed rows; the pair keeps its first
+// declared predicate so the relation survives the collapse.
 func (Parser) ParseGraphExport(body string) ([]domain.GraphNode, []domain.Edge) {
 	rawNodes, rawEdges := graphstore.ParseExport(body)
 	var nodes []domain.GraphNode
@@ -29,19 +30,23 @@ func (Parser) ParseGraphExport(body string) ([]domain.GraphNode, []domain.Edge)
 		nodes = append(nodes, domain.GraphNode{Ref: ref, Status: rawNodes[i].Status})
 	}
 	var edges []domain.Edge
-	seen := map[domain.Edge]struct{}{}
+	type pair struct{ from, to domain.Ref }
+	at := map[pair]int{}
 	for i := range rawEdges {
 		from, okF := parseMarkRef(rawEdges[i].From)
 		to, okT := parseMarkRef(rawEdges[i].To)
 		if !okF || !okT {
 			continue
 		}
-		e := domain.Edge{From: from, To: to, Type: domain.EdgeReference}
-		if _, dup := seen[e]; dup {
+		p := pair{from, to}
+		if j, dup := at[p]; dup {
+			if edges[j].Rel == "" {
+				edges[j].Rel = rawEdges[i].Rel
+			}
 			continue
 		}
-		seen[e] = struct{}{}
-		edges = append(edges, e)
+		at[p] = len(edges)
+		edges = append(edges, domain.Edge{From: from, To: to, Type: domain.EdgeReference, Rel: rawEdges[i].Rel})
 	}
 	return nodes, edges
 }

internal/adapter/outbound/graphexport/graphexport_test.go

@@ -60,6 +60,13 @@ var wantEdges = []domain.Edge{
 	{From: domain.Ref{World: "world-a.svc:6309", Path: "/guide.md"}, To: domain.Ref{World: "wiki.example.org", Path: "/notes.md"}, Type: domain.EdgeReference},
 }
 
+// The enriched fixture's plain and rel-typed rows for the same pair collapse
+// to one edge that keeps the predicate.
+var wantEnrichedEdges = []domain.Edge{
+	{From: domain.Ref{World: "root.svc:6309", Path: "/index.md"}, To: domain.Ref{World: "world-a.svc:6309", Path: "/guide.md"}, Type: domain.EdgeReference, Rel: "supersedes"},
+	{From: domain.Ref{World: "world-a.svc:6309", Path: "/guide.md"}, To: domain.Ref{World: "wiki.example.org", Path: "/notes.md"}, Type: domain.EdgeReference},
+}
+
 func TestParseGraphExportLegacy(t *testing.T) {
 	nodes, edges := Parser{}.ParseGraphExport(legacyExport)
 	if !reflect.DeepEqual(nodes, wantNodes) {
@@ -79,8 +86,8 @@ func TestParseGraphExportEnriched(t *testing.T) {
 	if !reflect.DeepEqual(nodes, wantNodes) {
 		t.Errorf("nodes = %+v, want %+v (edge rows must not become nodes)", nodes, wantNodes)
 	}
-	if !reflect.DeepEqual(edges, wantEdges) {
-		t.Errorf("edges = %+v, want %+v (rel duplicate collapsed)", edges, wantEdges)
+	if !reflect.DeepEqual(edges, wantEnrichedEdges) {
+		t.Errorf("edges = %+v, want %+v (pair collapsed, predicate kept)", edges, wantEnrichedEdges)
 	}
 }
 

internal/core/domain/document.go

@@ -152,12 +152,15 @@ const (
 // The floor renders these between world clusters (and to portal nodes); they
 // come from the durable hub graph export unioned with the R3 observed-links map.
 // Type lets the graph overlay draw references and drop/fade containment without
-// recomputing. Edge stays comparable (Type is a string), so it remains a map
-// key for the dedup sets in worldEdges/intraWorldEdges.
+// recomputing. Rel is the optional declared predicate of a typed relation
+// (rel-<predicate> publisher metadata, e.g. "supersedes"); "" for a plain body
+// link. Edge stays comparable, so it remains a map key for the dedup sets in
+// worldEdges/intraWorldEdges.
 type Edge struct {
 	From Ref
 	To   Ref
 	Type EdgeType
+	Rel  string
 }
 
 // WorldInfo is one world of the universe: a mark_worlds row in broker mode,

internal/core/service/worldmap.go

@@ -228,7 +228,10 @@ func topDir(path string) string {
 // own name. Hub edges are keyed by host, observed edges by world name; host2name
 // joins the former. Deduped and sorted for a stable, cacheable render.
 func intraWorldEdges(world string, host2name map[string]string, all []domain.Edge, labeled map[string]bool) []domain.Edge {
-	seen := map[domain.Edge]struct{}{}
+	// Dedup by remapped edge sans Rel; a pair keeps the first declared
+	// predicate it sees (a hub rel edge collapsing with its plain observed
+	// twin must not lose the relation).
+	at := map[domain.Edge]int{}
 	var out []domain.Edge
 	for _, e := range all {
 		if !worldMember(e.From.World, world, host2name) || !worldMember(e.To.World, world, host2name) {
@@ -242,10 +245,14 @@ func intraWorldEdges(world string, host2name map[string]string, all []domain.Edg
 			To:   domain.Ref{World: world, Path: e.To.Path},
 			Type: e.Type,
 		}
-		if _, dup := seen[ce]; dup {
+		if i, dup := at[ce]; dup {
+			if out[i].Rel == "" {
+				out[i].Rel = e.Rel
+			}
 			continue
 		}
-		seen[ce] = struct{}{}
+		at[ce] = len(out)
+		ce.Rel = e.Rel
 		out = append(out, ce)
 	}
 	sort.Slice(out, func(i, j int) bool {

internal/core/service/worldmap_test.go

@@ -283,3 +283,19 @@ func TestWorldMapDegradesOnReadError(t *testing.T) {
 		}
 	}
 }
+
+// A hub rel edge (host-keyed, remapped via host2name) collapsing with its
+// plain observed twin (already world-name form) keeps the predicate.
+func TestIntraWorldEdgesKeepsRel(t *testing.T) {
+	labeled := map[string]bool{"/a.md": true, "/b.md": true}
+	host2name := map[string]string{"w.w.svc:6309": "w"}
+	all := []domain.Edge{
+		{From: domain.Ref{World: "w", Path: "/a.md"}, To: domain.Ref{World: "w", Path: "/b.md"}, Type: domain.EdgeReference},
+		{From: domain.Ref{World: "w.w.svc:6309", Path: "/a.md"}, To: domain.Ref{World: "w.w.svc:6309", Path: "/b.md"}, Type: domain.EdgeReference, Rel: "supersedes"},
+	}
+	out := intraWorldEdges("w", host2name, all, labeled)
+	want := []domain.Edge{{From: domain.Ref{World: "w", Path: "/a.md"}, To: domain.Ref{World: "w", Path: "/b.md"}, Type: domain.EdgeReference, Rel: "supersedes"}}
+	if !reflect.DeepEqual(out, want) {
+		t.Errorf("edges = %+v, want %+v (predicate must survive remap and pair collapse)", out, want)
+	}
+}