feat(nav): worlds-only floor + reference-only world map

Author: ontehfritz

internal/adapter/inbound/web/floor.go

@@ -91,6 +91,62 @@ func floorSVG(floor domain.Floor, t trail, idx int) template.HTML {
 	return template.HTML(b.String()) //nolint:gosec // built here from escaped parts; node text/attrs all pass html.EscapeString
 }
 
+// floorCards renders the universe as worlds-only "door" cards (ADR 0006 §5):
+// the universe lists worlds, never loose documents. Each card reads as a door at
+// rest — a container glyph, the world name, a trailing chevron — affordances a
+// document row never has. Federated/remote worlds (portals) get a dashed,
+// external-link treatment: visibly "a server you connect to," not a local world
+// you enter. This is the default cold-entry view; floorSVG is the "view as map".
+func floorCards(floor domain.Floor, t trail, idx int) template.HTML {
+	if len(floor.Worlds) == 0 {
+		return template.HTML(`<p class="floor-empty">The universe is empty — no worlds visible to your identity.</p>`) //nolint:gosec // static markup
+	}
+	var b strings.Builder
+	b.WriteString(`<ul class="worlds">`)
+	for _, fw := range floor.Worlds {
+		cls := "world-card"
+		var href string
+		if fw.Portal {
+			cls += " federated"
+			href = trailURL(trailAfterClick(t, idx, paneAddr{Kind: paneDoc, World: fw.World.Name, Value: "/"}))
+		} else {
+			href = trailURL(trailAfterClick(t, idx, paneAddr{Kind: paneFloor, World: fw.World.Name}))
+		}
+		if fw.Err {
+			cls += " gone"
+		}
+		fmt.Fprintf(&b, `<li><a class="%s" href="%s">`, cls, html.EscapeString(href))
+		b.WriteString(`<span class="world-glyph" aria-hidden="true">▤</span>`)
+		fmt.Fprintf(&b, `<span class="world-name">%s</span>`, html.EscapeString(fw.World.Name))
+		switch {
+		case fw.Portal:
+			b.WriteString(`<span class="world-tag">federated · sign-in</span><span class="world-chev" aria-hidden="true">↗</span>`)
+		case fw.Err:
+			b.WriteString(`<span class="world-tag">unreadable</span>`)
+		default:
+			b.WriteString(`<span class="world-chev" aria-hidden="true">›</span>`)
+		}
+		b.WriteString(`</a></li>`)
+	}
+	b.WriteString(`</ul>`)
+	return template.HTML(b.String()) //nolint:gosec // built from html.EscapeString'd parts only
+}
+
+// floorViewToggle is the "view as map / worlds" switch (ADR 0006 §5): the
+// universe is worlds-by-default, with the federation topology a deliberate
+// secondary view at ?view=map.
+func floorViewToggle(t trail, mapView bool) template.HTML {
+	base := trailURL(t)
+	if mapView {
+		return template.HTML(`<a class="floor-view" href="` + html.EscapeString(base) + `">← worlds</a>`) //nolint:gosec // escaped
+	}
+	sep := "?"
+	if strings.Contains(base, "?") {
+		sep = "&"
+	}
+	return template.HTML(`<a class="floor-view" href="` + html.EscapeString(base+sep+"view=map") + `">view as map →</a>`) //nolint:gosec // escaped
+}
+
 // floorSystem renders one authorized world: the world node (zooms into the
 // world map) plus its top-importance documents as satellites on an orbit ring.
 func floorSystem(b *strings.Builder, fw domain.FloorWorld, c floorPoint, t trail, idx int) {

internal/adapter/inbound/web/floor_test.go

@@ -43,6 +43,35 @@ func TestFloorChunkRoundTrip(t *testing.T) {
 	}
 }
 
+func TestFloorCardsWorldsOnly(t *testing.T) {
+	floor := testFloor()
+	floor.Worlds = append(floor.Worlds, domain.FloorWorld{
+		World: domain.WorldInfo{Name: "remote.example.org"}, Portal: true,
+	})
+	tr := trail{Panes: []paneAddr{{Kind: paneFloor}}, Focus: 0}
+	out := string(floorCards(floor, tr, 0))
+
+	// Worlds render as door cards; no loose documents at the universe level.
+	if !strings.Contains(out, `class="world-card"`) {
+		t.Error("expected world door cards")
+	}
+	if strings.Contains(out, "Hub") || strings.Contains(out, "ADR 0005") {
+		t.Errorf("universe must list worlds only, not documents: %s", out)
+	}
+	// Authorized world card → zoom to its map.
+	if !strings.Contains(out, `href="/t/u/~/team-a/u/"`) {
+		t.Errorf("world card should link to its map: %s", out)
+	}
+	// Federated/remote world → dashed federated door with an external root link.
+	if !strings.Contains(out, "world-card federated") || !strings.Contains(out, "federated · sign-in") {
+		t.Errorf("portal world should render as a federated door: %s", out)
+	}
+	// Unreadable world still renders, tagged (absence would read as nonexistence).
+	if !strings.Contains(out, "unreadable") {
+		t.Errorf("unreadable world should render, tagged: %s", out)
+	}
+}
+
 func TestFloorSVGNodesAndLinks(t *testing.T) {
 	tr := trail{Panes: []paneAddr{{Kind: paneFloor}}, Focus: 0}
 	svg := string(floorSVG(testFloor(), tr, 0))
@@ -120,8 +149,10 @@ func TestTrailFloorPaneFocusedLive(t *testing.T) {
 	if got := strings.Join(svc.calls, ","); got != want {
 		t.Errorf("calls = %q, want %q", got, want)
 	}
-	if !strings.Contains(rec.Body.String(), `svg class="floor"`) {
-		t.Errorf("floor svg missing from body pane")
+	// ADR 0006 §5: the universe renders worlds-only door cards by default
+	// (the SVG topology is the secondary ?view=map).
+	if !strings.Contains(rec.Body.String(), `class="world-card"`) {
+		t.Errorf("floor body pane missing world cards")
 	}
 
 	svc2 := &fakeReading{floor: testFloor()}

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

@@ -170,10 +170,14 @@
     .floor-edge { stroke: var(--faint); stroke-width: 1.5; }
     .floor-portal-node { fill: var(--paper); stroke: var(--muted);
                          stroke-width: 1.5; stroke-dasharray: 3 2; }
-    /* World map (zoom level 2): the "+N more" aggregate bubble opens a dir's
-       listing pane. Directory hubs reuse .floor-world; docs reuse .floor-doc. */
-    .world-map-more { fill: var(--faint); stroke: var(--muted); stroke-width: 1.5; }
+    /* World map (zoom level 2), reference-only (ADR 0006 §5): linked docs in a
+       connected ring (reuse .floor-doc + .graph-edge), orphans floated in a band
+       below — dashed + dimmed so "unconnected" reads at a glance. */
     .world-map .floor-doc-label { fill: var(--ink); }
+    .world-map-caption { font-family: system-ui, sans-serif; font-size: 11px; fill: var(--muted); }
+    .world-map-band { font-family: system-ui, sans-serif; font-size: 10px; fill: var(--muted);
+                      text-transform: uppercase; letter-spacing: .05em; }
+    .floor-doc.world-map-orphan { stroke-dasharray: 3 2; opacity: .7; }
     .world-map-new { margin-top: .6rem; font-family: system-ui, sans-serif; font-size: .85rem; }
 
     /* ── Backlinks: the observed-links map made visible (R3). Last margin
@@ -320,6 +324,28 @@
                   font-size: .7rem; color: var(--muted); }
     @media (max-width: 640px) { .palette-loc { display: none; } }
 
+    /* ── World index (ADR 0006 §5): the universe lists worlds as doors, never
+          loose documents. A card carries door affordances (glyph, chevron) a
+          document row never has; federated worlds read as a remote server. ── */
+    .floor-view { font-family: system-ui, sans-serif; font-size: .75rem;
+            color: var(--muted); text-decoration: none; }
+    .floor-view:hover { color: var(--ink); }
+    .worlds { list-style: none; margin: 1rem 0 0; padding: 0;
+            display: grid; gap: .6rem; }
+    .world-card { display: flex; align-items: center; gap: .7rem;
+            padding: .7rem .9rem; border: 1px solid var(--faint); border-radius: 8px;
+            text-decoration: none; color: inherit; font-family: system-ui, sans-serif; }
+    .world-card:hover { border-color: var(--muted); background: var(--faint); }
+    .world-glyph { font-size: 1.1rem; color: var(--muted); }
+    .world-name { font-weight: 600; }
+    .world-chev { margin-left: auto; color: var(--muted); }
+    .world-tag { margin-left: auto; font-size: .65rem; text-transform: uppercase;
+            letter-spacing: .04em; color: var(--muted); border: 1px solid var(--faint);
+            border-radius: 4px; padding: 0 .35rem; }
+    .world-card.federated { border-style: dashed; }
+    .world-card.federated .world-chev { margin-left: .4rem; }
+    .world-card.gone { opacity: .55; }
+
     /* ── Trail dock (ADR 0006 §2): bottom orientation strip. Fixed; <details>
           gives zero-JS minimize. System-ui sans — an instrument, not prose. ── */
     body.canvas-page { padding-bottom: 4.5rem; }

internal/adapter/inbound/web/trail_handlers.go

@@ -90,7 +90,7 @@ func (h *ReadingHandler) Trail(c *echo.Context) error {
 			var err error
 			scope := "universe"
 			if addr.World == "" {
-				pane, err = h.floorPaneView(ctx, t, i)
+				pane, err = h.floorPaneView(ctx, t, i, c.QueryParam("view") == "map")
 			} else {
 				scope = addr.World
 				pane, err = h.worldMapPaneView(ctx, t, i, addr, authed)
@@ -159,7 +159,7 @@ func (h *ReadingHandler) Trail(c *echo.Context) error {
 // floorPaneView builds the universe pane: floor data (focused-live like
 // every pane), rendered as trail-aware SVG. The floor has no margin — its
 // trust signals are ON the nodes (status strokes, importance sizing).
-func (h *ReadingHandler) floorPaneView(ctx context.Context, t trail, i int) (paneVM, error) {
+func (h *ReadingHandler) floorPaneView(ctx context.Context, t trail, i int, mapView bool) (paneVM, error) {
 	focused := i == t.Focus
 	var floor domain.Floor
 	var err error
@@ -187,7 +187,13 @@ func (h *ReadingHandler) floorPaneView(ctx context.Context, t trail, i int) (pan
 		World:    "universe",
 	}
 	if mode != "spine" {
-		vm.Content = floorSVG(floor, t, i)
+		// Worlds-only door cards by default (ADR 0006 §5); the SVG topology is
+		// the deliberate "view as map" secondary view.
+		body := floorCards(floor, t, i)
+		if mapView {
+			body = floorSVG(floor, t, i)
+		}
+		vm.Content = floorViewToggle(t, mapView) + body
 	}
 	return vm, nil
 }