diff --git a/app/src/components/Explorer.tsx b/app/src/components/Explorer.tsx
index fedc6c9a..292eb280 100644
--- a/app/src/components/Explorer.tsx
+++ b/app/src/components/Explorer.tsx
@@ -1,5 +1,5 @@
 import type { ComponentChildren } from 'preact';
-import { useCallback, useEffect, useMemo, useRef, useState } from 'preact/hooks';
+import { useCallback, useEffect, useLayoutEffect, useMemo, useRef, useState } from 'preact/hooks';
 import { prerequisitesOf, shortestPath, type Graph, type GraphNode } from '../lib/graph-model';
 import { loadLearner, type Learner } from '../lib/learner';
 import {
@@ -57,6 +57,18 @@ type Mode = '2d' | '3d';
 type ColourMode = 'cluster' | 'knowledge';
 /** The control bar's popovers; only one is open at a time ('sheet' = phones' Controls). */
 type Pop = 'links' | 'route' | 'sheet';
+/**
+ * How much of the control bar fits (A93b): named domain pills and an open search field
+ * when there is room, dot chips next, then short labels and a search icon, and — when
+ * even that would wrap — the phones' "Controls" sheet. Measured, never a second row.
+ */
+type BarSize = 'full' | 'medium' | 'compact' | 'sheet';
+const SMALLER: Record<BarSize, BarSize> = {
+  full: 'medium',
+  medium: 'compact',
+  compact: 'sheet',
+  sheet: 'sheet',
+};
 /** A term under a resting pointer, in map pixels (the hover card's anchor). */
 type Point = { id: string; x: number; y: number };
 
@@ -142,6 +154,43 @@ export default function Explorer(props: Props) {
     return () => mq.removeEventListener('change', on);
   }, []);
   const bar = useRef<HTMLDivElement>(null);
+  /** The space the bar is centred in (between the legend and the "i"). */
+  const slot = useRef<HTMLDivElement>(null);
+  const [barSize, setBarSize] = useState<BarSize>('full');
+  // Start from the fullest bar whenever the space (or what the bar holds) changes...
+  useEffect(() => {
+    const el = slot.current;
+    if (!el) return;
+    let width = el.clientWidth;
+    const ro = new ResizeObserver(() => {
+      if (el.clientWidth === width) return;
+      width = el.clientWidth;
+      setBarSize('full');
+    });
+    ro.observe(el);
+    return () => ro.disconnect();
+  }, []);
+  /** Phones, or a desktop bar too tight for one row: the "Controls" sheet. */
+  const sheet = narrow || barSize === 'sheet';
+  // ...and step down, before paint, while its one row overflows.
+  useLayoutEffect(() => {
+    const b = bar.current;
+    // An opened search field in a compact bar may overflow a little: never a sheet for it.
+    if (barSize === 'sheet' || (barSize === 'compact' && findOpen)) return;
+    // In-flow widths only: an open popover or result list must not shrink the bar.
+    const room = slot.current?.clientWidth ?? 0;
+    const need = (el: HTMLElement) => {
+      const kids = [...el.children] as HTMLElement[];
+      const gap = parseFloat(getComputedStyle(el).columnGap) || 0;
+      const pad = el.offsetWidth - el.clientWidth + 12; // border + px-1.5 padding
+      return (
+        kids.reduce((w, k) => w + k.getBoundingClientRect().width, 0) +
+        gap * (kids.length - 1) +
+        pad
+      );
+    };
+    if (b && !narrow && room && need(b) > room + 1) setBarSize(SMALLER[barSize]);
+  });
   // A popover closes on Esc (focus back on its button) or a press outside the bar. The
   // term panel's Esc handler stands down while a [data-map-popover] is open.
   useEffect(() => {
@@ -356,6 +405,7 @@ export default function Explorer(props: Props) {
           onHover: (id) => prefetchTerm(props.panel.apiBase, id),
           onPoint,
           theme,
+          domainLabels: props.domainLabels,
         }),
       )
       .then((m) => {
@@ -368,6 +418,7 @@ export default function Explorer(props: Props) {
   }, [mode, graph]);
   useEffect(() => () => map3d?.destroy(), [map3d]);
   useEffect(() => map3d?.spin(spin), [map3d, spin]);
+  useEffect(() => setBarSize('full'), [mode, legendOpen, lang]);
   useEffect(() => map3d?.retheme(theme), [map3d, theme]);
   useEffect(() => {
     onPoint(null);
@@ -550,10 +601,10 @@ export default function Explorer(props: Props) {
         <span aria-hidden="true">⟳</span> {ui.autoRotate}
       </button>
     );
-  /** Domain toggles: labelled pills in the phone sheet, dot-only chips in the bar. */
-  const domainPills = (compact: boolean) => (
+  /** Domain toggles: labelled pills (the sheet, a full bar) or dot-only chips (a tighter bar). */
+  const domainPills = (compact: boolean, wrap = true) => (
     <div
-      class={`flex flex-wrap items-center ${compact ? 'gap-1' : 'gap-1.5'}`}
+      class={`flex shrink-0 ${wrap ? 'flex-wrap' : ''} items-center ${compact ? 'gap-1' : 'gap-1.5'}`}
       role="group"
       aria-label={ui.domains}
       data-tour="explorer-filters"
@@ -670,9 +721,9 @@ export default function Explorer(props: Props) {
       )}
     </form>
   );
-  // In the bar, "Find a term" is a search icon that opens the field (keeps the bar one row).
+  // In a compact bar, "Find a term" is a search icon that opens the field (keeps one row).
   const search =
-    !narrow && !findOpen ? (
+    barSize === 'compact' && !findOpen ? (
       <button
         type="button"
         class={`${pill(false)} px-2`}
@@ -715,14 +766,14 @@ export default function Explorer(props: Props) {
               else setFindOpen(false);
             }
           }}
-          class={`${field} ${narrow ? '' : 'w-40'}`}
+          class={`${field} ${sheet ? '' : barSize === 'full' ? 'w-56' : 'w-44'}`}
         />
         {query.trim() && (
           <ul
             id="xp-find"
             aria-live="polite"
             aria-label={ui.findTerm}
-            class={`${narrow ? 'mt-2' : `absolute top-full left-0 z-20 mt-2 w-64 max-w-[calc(100vw-2rem)] ${glass}`} space-y-0.5 rounded-xl p-2 text-xs`}
+            class={`${sheet ? 'mt-2' : `absolute top-full left-0 z-20 mt-2 w-64 max-w-[calc(100vw-2rem)] ${glass}`} space-y-0.5 rounded-xl p-2 text-xs`}
           >
             {matches.length === 0 && <li class="px-1 text-subtle">{ui.noResults}</li>}
             {matches.map((m) => (
@@ -818,20 +869,22 @@ export default function Explorer(props: Props) {
         below it.
       */}
       <div
-        class={`pointer-events-none absolute top-3 right-14 left-14 z-20 flex flex-col items-center gap-1.5 md:right-36 ${legendOpen ? 'md:left-[18rem]' : 'md:left-36'}`}
+        ref={slot}
+        class={`pointer-events-none absolute top-3 right-14 left-14 z-20 flex flex-col items-center gap-1.5 md:right-36 ${legendOpen ? 'md:left-(--xp-legend-open)' : 'md:left-(--xp-legend)'}`}
       >
         <div
           ref={bar}
+          data-size={sheet ? 'sheet' : barSize}
           role="group"
           aria-label={ui.mapControls}
           data-explorer-bar
-          class={`pointer-events-auto relative flex max-w-full flex-wrap items-center justify-center gap-x-1.5 gap-y-1.5 rounded-2xl px-1.5 py-1.5 text-sm ${glass}`}
+          class={`pointer-events-auto relative flex max-w-full flex-nowrap items-center justify-center gap-1.5 rounded-2xl px-1.5 py-1.5 text-sm ${glass}`}
         >
-          <div class="flex items-center gap-1.5" data-tour="explorer-layouts">
+          <div class="flex shrink-0 items-center gap-1.5" data-tour="explorer-layouts">
             {modeSeg}
-            {!narrow && layoutSeg}
+            {!sheet && layoutSeg}
           </div>
-          {narrow ? (
+          {sheet ? (
             <>
               {popButton('sheet', ui.controls)}
               {pop === 'sheet' && (
@@ -866,21 +919,25 @@ export default function Explorer(props: Props) {
             </>
           ) : (
             <>
-              {domainPills(true)}
-              <div class="relative">
-                {popButton('links', ui.linksShort, showAll)}
+              {domainPills(barSize !== 'full', false)}
+              <div class="relative shrink-0">
+                {popButton(
+                  'links',
+                  barSize === 'compact' ? ui.linksShort : ui.relationshipTypes,
+                  showAll,
+                )}
                 {popover('links', ui.relationshipTypes, linksBody)}
               </div>
               {colourBody}
               {search}
-              <div class="relative" data-tour="explorer-route">
+              <div class="relative shrink-0" data-tour="explorer-route">
                 {popButton('route', ui.routeShort, highlight.length > 0 && !!routeMsg)}
                 {popover('route', ui.route, routeBody, 'right-0')}
               </div>
             </>
           )}
         </div>
-        {!narrow && note && (
+        {!sheet && note && (
           <p class="max-w-2xl rounded-full bg-bg/70 px-3 py-0.5 text-center text-[11px] text-muted">
             {note}
           </p>
diff --git a/app/src/lib/explorer-2d.ts b/app/src/lib/explorer-2d.ts
index 7aa757de..e5f1860d 100644
--- a/app/src/lib/explorer-2d.ts
+++ b/app/src/lib/explorer-2d.ts
@@ -628,31 +628,43 @@ export function createMap2D(opts: Map2DOptions) {
   /** Elements currently displayed — hover fades only these. */
   let shown = cy.collection();
 
-  /** The backbone over the families switched on, recomputed when they change. */
-  let spineFor: ReadonlySet<string> | null = null;
+  /**
+   * The backbone over the families switched on and the terms shown, recomputed when
+   * either changes: a term whose strongest links went to hidden terms keeps a visible one.
+   */
+  let spineFor: [ReadonlySet<string>, ReadonlySet<string>] | null = null;
   /**
    * Which edges are drawn, and how (backbone / all / focus). The families filter the
    * overview only: a selected term shows every one of its relationships.
    */
-  const refreshEdges = () => {
-    if (!view) return;
+  const refreshEdges = (defer = false): EdgeChange[] => {
+    const changes: EdgeChange[] = [];
+    if (!view) return changes;
     const v = view;
     const sel = v.selected;
     const hl = v.highlight;
-    const spine = spineFor === v.families ? null : backboneOf(graph.nodes, graph.links, v.families);
-    spineFor = v.families;
+    const spine =
+      spineFor?.[0] === v.families && spineFor[1] === v.nodes
+        ? null
+        : backboneOf(graph.nodes, graph.links, v.families, v.nodes);
+    spineFor = [v.families, v.nodes];
     cy.batch(() => {
-      links.forEach((e) => {
-        const s = e.data('source');
-        const t = e.data('target');
-        if (spine) e.toggleClass('bb', spine.has(Number(e.id().slice(1))));
+      // Worked out in plain data; only edges whose classes change are touched (A93b):
+      // a toggle then restyles the edges it changes, not every edge. `defer` hands the
+      // changes back to be applied a batch per frame.
+      edgeMeta.forEach((m, i) => {
+        const { s, t, e } = m;
+        if (spine) m.bb = spine.has(i);
         const shown = linkVisible({ source: s, target: t }, v.nodes);
-        const ends = shown && v.families.has(graphFamily(e));
+        const ends = shown && v.families.has(m.family);
         const focus = (shown && (s === sel || t === sel)) || (ends && hl.has(s) && hl.has(t));
-        const on = focus || (ends && (v.showAll || e.hasClass('bb')));
-        e.toggleClass('off', !on);
-        e.toggleClass('all', on && v.showAll);
-        e.toggleClass('focus', focus);
+        const on = focus || (ends && (v.showAll || m.bb));
+        const bits = (m.bb ? 1 : 0) | (on ? 0 : 2) | (on && v.showAll ? 4 : 0) | (focus ? 8 : 0);
+        if (bits === m.bits && e.hasClass('off') === !on) return;
+        m.bits = bits;
+        const c = { e, bb: m.bb, on, all: on && v.showAll, focus };
+        if (defer) changes.push(c);
+        else applyEdge(c);
       });
       // Bundles summarise the visible cross-cluster relationships in the force overview.
       const counts =
@@ -678,17 +690,45 @@ export function createMap2D(opts: Map2DOptions) {
       });
     });
     shown = cy.elements().not('.gone, .off, .anchor');
+    return changes;
   };
   const graphFamily = (e: cytoscape.EdgeSingular) => graph.links[Number(e.id().slice(1))].family;
+  type EdgeChange = {
+    e: cytoscape.EdgeSingular;
+    bb: boolean;
+    on: boolean;
+    all: boolean;
+    focus: boolean;
+  };
+  const applyEdge = (c: EdgeChange) =>
+    c.e
+      .toggleClass('bb', c.bb)
+      .toggleClass('off', !c.on)
+      .toggleClass('all', c.all)
+      .toggleClass('focus', c.focus);
+  /** Each relationship's edge, ends and family by index, and its last class bits. */
+  const edgeMeta = graph.links.map((l, i) => ({
+    e: cy.getElementById(`e${i}`) as cytoscape.EdgeSingular,
+    s: l.source,
+    t: l.target,
+    family: l.family,
+    bb: false,
+    bits: -1,
+  }));
 
   /** Bundled routes for cross-cluster edges drawn in full ("show all", force layout). */
   let bundled = false;
-  const setBundledRoutes = (on: boolean, centre?: Record<string, Point>) => {
+  /** `only`: just these edges (a batch of a staggered reveal), the rest already done. */
+  const setBundledRoutes = (
+    on: boolean,
+    centre?: Record<string, Point>,
+    only?: cytoscape.EdgeCollection,
+  ) => {
     // Clearing routes that were never set restyles every cross-cluster edge for nothing.
-    if (!on && !bundled) return;
+    if (!on && !bundled && !only) return;
     bundled = on && !!centre;
     cy.batch(() => {
-      links.filter('.xc').forEach((e) => {
+      (only ?? links).filter('.xc').forEach((e) => {
         if (!on || !centre) {
           e.removeStyle('curve-style control-point-distances control-point-weights');
           return;
@@ -910,6 +950,43 @@ export function createMap2D(opts: Map2DOptions) {
   };
 
   // ---- 7. Applying a view ------------------------------------------------------------
+  /** A staggered edge change in flight: its remaining batches, and what ends it. */
+  let pending: { rest: () => void; raf: number } | null = null;
+  /** Finish a staggered change at once (a new view is about to be applied). */
+  const flushStagger = () => {
+    if (!pending) return;
+    cancelAnimationFrame(pending.raf);
+    const p = pending;
+    pending = null;
+    p.rest();
+  };
+  /**
+   * Run `step` over `edges` a batch per frame (`EXPLORER.motion.revealBatch`) inside a
+   * Cytoscape batch (no per-edge fade: a style bypass per edge costs more than the batch).
+   */
+  const inBatches = <T>(all: T[], step: (chunk: T[]) => void, end: () => void) => {
+    const n = EXPLORER.motion.revealBatch;
+    let i = 0;
+    const run = (count: number) => {
+      const chunk = all.slice(i, (i += count));
+      cy.batch(() => step(chunk));
+    };
+    const tick = () => {
+      run(n);
+      if (i < all.length) pending!.raf = requestAnimationFrame(tick);
+      else {
+        pending = null;
+        end();
+      }
+    };
+    pending = {
+      raf: requestAnimationFrame(tick),
+      rest: () => {
+        run(all.length - i);
+        end();
+      },
+    };
+  };
   let familiesNow: ReadonlySet<string> | null = null;
   const apply = (next: View) => {
     const prev = view;
@@ -953,30 +1030,64 @@ export function createMap2D(opts: Map2DOptions) {
             return familiesNow!.has(f) && !next.families.has(f) && !e.hasClass('off') && !mine;
           })
         : cy.collection();
-    const familiesOn =
-      prev && familiesNow && familiesNow !== next.families && !reducedMotion()
-        ? new Set([...next.families].filter((f) => !familiesNow!.has(f)))
-        : null;
     familiesNow = next.families;
+    flushStagger();
+    const fadeIn = (edges: cytoscape.EdgeCollection) =>
+      edges.forEach((e) => {
+        const target = Number(e.style('opacity'));
+        e.style('opacity', 0).animate(
+          { style: { opacity: target } },
+          { duration: EXPLORER.motion.fadeMs, complete: () => void e.removeStyle('opacity') },
+        );
+      });
     const finish = () => {
-      const wasOff = familiesOn?.size ? links.filter('.off') : null;
-      refreshEdges();
-      // …and fade in when switched back on.
-      if (wasOff)
-        wasOff
-          .filter((e) => !e.hasClass('off') && familiesOn!.has(graphFamily(e)))
-          .forEach((e) => {
-            const target = Number(e.style('opacity'));
-            e.style('opacity', 0).animate(
-              { style: { opacity: target } },
-              {
-                duration: EXPLORER.motion.fadeMs,
-                complete: () => void e.removeStyle('opacity'),
-              },
-            );
-          });
-      if (prev?.showAll !== next.showAll || layoutChanged)
-        setBundledRoutes(next.layout === 'force' && next.showAll, centreNow);
+      // Many edges switched on or off by a toggle (types, "show all") change a batch per
+      // frame (A93b); a few fade in at once. Instant under reduced motion.
+      const toggled = prev && (prev.families !== next.families || prev.showAll !== next.showAll);
+      const stagger = !!toggled && !layoutChanged && !reducedMotion();
+      const routes = prev?.showAll !== next.showAll || layoutChanged;
+      const bundle = next.layout === 'force' && next.showAll;
+      const changes = refreshEdges(stagger);
+      const edgesOf = (cs: EdgeChange[]) =>
+        cy.collection(cs.map((c) => c.e)) as cytoscape.EdgeCollection;
+      /** Apply changes; the edges they switch on get bundled routes when those are on. */
+      const land = (cs: EdgeChange[]) => {
+        const arriving = edgesOf(cs.filter((c) => c.on && c.e.hasClass('off')));
+        cs.forEach(applyEdge);
+        if (bundle && !routes) setBundledRoutes(true, centreNow, arriving);
+        return arriving;
+      };
+      if (changes.length > EXPLORER.motion.revealBatch) {
+        // Routes now for the edges that stay shown; the rest get theirs with their batch.
+        const changing = edgesOf(changes);
+        if (routes)
+          setBundledRoutes(bundle, centreNow, (bundle ? links.not('.off') : links).not(changing));
+        inBatches(
+          changes,
+          (chunk) => {
+            land(chunk);
+            if (routes) setBundledRoutes(bundle, centreNow, edgesOf(chunk));
+          },
+          () => {
+            shown = cy.elements().not('.gone, .off, .anchor');
+            paintFocus();
+          },
+        );
+      } else {
+        // A small change (or reduced motion): at once, new edges fading in.
+        let arriving = cy.collection() as cytoscape.EdgeCollection;
+        cy.batch(() => void (arriving = land(changes)));
+        shown = cy.elements().not('.gone, .off, .anchor');
+        if (routes) setBundledRoutes(bundle, centreNow);
+        if (stagger) fadeIn(arriving);
+      }
+      paintFocus();
+      if (nodesChanged && !layoutChanged) {
+        recull(true);
+        frame();
+      }
+    };
+    const paintFocus = () =>
       cy.batch(() => {
         cy.elements('.sel, .hl, .dim, .nb').removeClass('sel hl dim nb');
         const tags = cy.nodes('.tag');
@@ -1001,11 +1112,6 @@ export function createMap2D(opts: Map2DOptions) {
         }
         if (next.selected) cy.getElementById(next.selected).removeClass('dim').addClass('sel');
       });
-      if (nodesChanged && !layoutChanged) {
-        recull(true);
-        frame();
-      }
-    };
     if (fading.nonempty())
       fading.animate(
         { style: { opacity: 0 } },
@@ -1091,6 +1197,8 @@ export function createMap2D(opts: Map2DOptions) {
     },
     destroy() {
       dots.stop();
+      if (pending) cancelAnimationFrame(pending.raf);
+      pending = null;
       window.clearTimeout(cullTimer);
       window.clearTimeout(hoverTimer);
       drag.destroy();
diff --git a/app/src/lib/explorer-3d.ts b/app/src/lib/explorer-3d.ts
index ba0da583..77498af2 100644
--- a/app/src/lib/explorer-3d.ts
+++ b/app/src/lib/explorer-3d.ts
@@ -11,6 +11,7 @@ import { EXPLORER } from './explorer-config';
 import {
   MAP_INK,
   clusterColour,
+  domainColour,
   familyColours,
   homeDomain,
   isDirected,
@@ -54,6 +55,8 @@ export async function createMap3D(opts: {
   onPoint?: (hit: { id: string; x: number; y: number } | null) => void;
   /** The scene's palette (A92); change it later with `retheme`. */
   theme?: MapTheme;
+  /** Each domain's name, written large and faint across its galaxy (A93b). */
+  domainLabels?: Record<string, string>;
 }) {
   const [{ default: ForceGraph3D }, THREE] = await Promise.all([
     import('3d-force-graph'),
@@ -277,6 +280,49 @@ export async function createMap3D(opts: {
     scene.add(sprite);
   }
 
+  // ---- Domain names: large, faint text across each galaxy, like the 2D map (A93b) -----
+  // Sprites always face the camera; they are not 3d-force-graph objects, so they never
+  // take a click or a hover.
+  const domainArt: {
+    domain: string;
+    ids: string[];
+    c: HTMLCanvasElement;
+    tex: { needsUpdate: boolean };
+    sprite: InstanceType<typeof THREE.Sprite>;
+  }[] = [];
+  const dpx = 120;
+  const drawDomain = (d: string, c: HTMLCanvasElement) => {
+    const g = c.getContext('2d')!;
+    g.clearRect(0, 0, c.width, c.height);
+    g.font = `700 ${dpx}px system-ui, sans-serif`;
+    g.textAlign = 'center';
+    g.textBaseline = 'middle';
+    g.fillStyle = domainColour(d, theme);
+    g.fillText(opts.domainLabels?.[d] ?? d, c.width / 2, c.height / 2);
+  };
+  for (const d of [...new Set(nodes.map(homeDomain))]) {
+    const own = nodes.filter((n) => homeDomain(n) === d);
+    const mid = (k: 'x' | 'y' | 'z') => own.reduce((s, n) => s + n[k], 0) / own.length;
+    const c = document.createElement('canvas');
+    const g = c.getContext('2d')!;
+    g.font = `700 ${dpx}px system-ui, sans-serif`;
+    c.width = Math.ceil(g.measureText(opts.domainLabels?.[d] ?? d).width) + 40;
+    c.height = dpx + 40;
+    drawDomain(d, c);
+    const tex = new THREE.CanvasTexture(c);
+    const sprite = new THREE.Sprite(
+      new THREE.SpriteMaterial({ map: tex, transparent: true, depthWrite: false, fog: false }),
+    );
+    const h = cfg.domainLabelHeight;
+    sprite.scale.set((h * c.width) / c.height, h, 1);
+    // Just above the galaxy, so the name labels its region without covering its terms.
+    const top = Math.max(...own.map((n) => n.y));
+    sprite.position.set(mid('x'), top + h * 0.5, mid('z'));
+    sprite.renderOrder = -1;
+    domainArt.push({ domain: d, ids: own.map((n) => n.id), c, tex, sprite });
+    scene.add(sprite);
+  }
+
   // ---- The resting web: every link as a gently curved polyline in one geometry --------
   const SEG = 8;
   /** Each link's curve (start, bend, end), shared with the flow particles. */
@@ -342,25 +388,45 @@ export async function createMap3D(opts: {
    * Night map (additive): a colour's brightness is its opacity; black is invisible.
    * Cream map (multiply): a colour mixed towards white by its opacity; white is invisible.
    */
-  const paintWeb = () => {
+  /** Each link's drawn strength (0 = hidden), and links still waiting to appear. */
+  const webK = new Float32Array(links.length);
+  let waiting: { i: number; k: number }[] = [];
+  let revealRaf = 0;
+  const writeWeb = (i: number, k: number) => {
+    webK[i] = k;
+    const c = webTint[i] ?? tints[i];
+    const g = k * webGain[i];
+    const kk = light() ? Math.min(1, g * 1.5) : g;
+    for (let j = 0; j < SEG * 2; j++)
+      webCol.set(
+        light()
+          ? [1 - (1 - c.r) * kk, 1 - (1 - c.g) * kk, 1 - (1 - c.b) * kk]
+          : [c.r * kk, c.g * kk, c.b * kk],
+        (i * SEG * 2 + j) * 3,
+      );
+  };
+  /** Links a toggle switched on arrive a batch per frame (A93b); instant otherwise. */
+  const revealTick = () => {
+    for (const { i, k } of waiting.splice(0, EXPLORER.motion.revealBatch)) writeWeb(i, k);
+    webColours.needsUpdate = true;
+    revealRaf = waiting.length ? requestAnimationFrame(revealTick) : 0;
+  };
+  const paintWeb = (stagger = false) => {
+    cancelAnimationFrame(revealRaf);
+    revealRaf = 0;
+    const next: { i: number; k: number }[] = [];
     links.forEach((l, i) => {
       let k = 0;
       if (view && endsShown(l) && (view.showAll || l.bb) && !focusOf(l)) {
         const dim = faded(endId(l.source)) || faded(endId(l.target));
         k = dim ? 0.02 : view.showAll && !l.bb ? cfg.linkAlpha * 0.6 : cfg.linkAlpha;
       }
-      const c = webTint[i] ?? tints[i];
-      k *= webGain[i];
-      if (light()) k = Math.min(1, k * 1.5);
-      for (let j = 0; j < SEG * 2; j++)
-        webCol.set(
-          light()
-            ? [1 - (1 - c.r) * k, 1 - (1 - c.g) * k, 1 - (1 - c.b) * k]
-            : [c.r * k, c.g * k, c.b * k],
-          (i * SEG * 2 + j) * 3,
-        );
+      if (stagger && motion && k > 0 && webK[i] === 0) next.push({ i, k });
+      else writeWeb(i, k);
     });
+    waiting = next;
     webColours.needsUpdate = true;
+    if (waiting.length) revealRaf = requestAnimationFrame(revealTick);
   };
 
   // ---- Flow: a small comet drifting along every visible one-way link (A86) -----------
@@ -520,8 +586,8 @@ export async function createMap3D(opts: {
   };
   setBlend();
 
-  const paintGlow = () => {
-    paintWeb();
+  const paintGlow = (stagger = false) => {
+    paintWeb(stagger);
     paintFlow();
     const col = new THREE.Color();
     nodes.forEach((n, i) => {
@@ -541,6 +607,12 @@ export async function createMap3D(opts: {
       s.visible = !!view?.nodes.has(id);
       s.material.opacity = faded(id) ? 0.12 : 1;
     }
+    // A domain's name shows while any of its own terms does; it recedes with a selection.
+    const quiet = !!(hover || view?.selected || view?.highlight.size);
+    for (const a of domainArt) {
+      a.sprite.visible = a.ids.some((id) => view?.nodes.has(id));
+      a.sprite.material.opacity = cfg.domainLabelAlpha[theme] * (quiet ? 0.35 : 1);
+    }
   };
 
   /** Re-evaluate the accessors (3d-force-graph's idiom) and land any new objects. */
@@ -652,13 +724,27 @@ export async function createMap3D(opts: {
     apply(next: View3D) {
       const prev = view;
       view = next;
-      if (prev?.families !== next.families) {
-        const spine = backboneOf(graph.nodes, graph.links, next.families);
+      if (prev?.families !== next.families || prev?.nodes !== next.nodes) {
+        // Over the shown terms only, so none is stranded by a hidden domain.
+        const spine = backboneOf(graph.nodes, graph.links, next.families, next.nodes);
         for (const l of links) l.bb = spine.has(l.i);
       }
       const nodesChanged = !prev || prev.nodes !== next.nodes;
       if (nodesChanged) fg.nodeVisibility(fg.nodeVisibility());
-      refresh();
+      // Only the relationship types or "show all" changed, with nothing focused: no
+      // 3d-force-graph object can change, so skip re-evaluating its accessors and
+      // reveal the web a batch per frame (A93b).
+      const toggleOnly =
+        !!prev &&
+        !nodesChanged &&
+        !hover &&
+        prev.selected === next.selected &&
+        prev.highlight === next.highlight &&
+        !next.highlight.size &&
+        prev.colour === next.colour &&
+        prev.bands === next.bands;
+      if (toggleOnly) paintGlow(true);
+      else refresh();
       // Opening or closing the term panel changes the part of the canvas left clear.
       if (!!next.selected !== !!prev?.selected) resize();
       if (next.selected && next.selected !== prev?.selected) flyTo(next.selected);
@@ -715,6 +801,10 @@ export async function createMap3D(opts: {
         drawLabel(a.text, a.c);
         a.tex.needsUpdate = true;
       }
+      for (const a of domainArt) {
+        drawDomain(a.domain, a.c);
+        a.tex.needsUpdate = true;
+      }
       refresh();
     },
     /** Re-frame after the clear part of the canvas changed (e.g. the legend toggled). */
@@ -730,6 +820,7 @@ export async function createMap3D(opts: {
     },
     destroy() {
       runFlow(false);
+      cancelAnimationFrame(revealRaf);
       window.clearTimeout(hoverTimer);
       window.removeEventListener('resize', resize);
       window.removeEventListener('pointerup', onRelease);
diff --git a/app/src/lib/explorer-config.ts b/app/src/lib/explorer-config.ts
index 702afa3e..441a71dc 100644
--- a/app/src/lib/explorer-config.ts
+++ b/app/src/lib/explorer-config.ts
@@ -93,6 +93,11 @@ export const EXPLORER = {
     layoutMs: 700,
     /** Edges fade in / out when a relationship family is toggled. */
     fadeMs: 180,
+    /**
+     * Edges a relationship toggle switches on or off (types, "show all") change this many
+     * per frame (A93b), so one toggle never restyles every edge in a single frame.
+     */
+    revealBatch: 120,
     fitMs: 550,
   },
 
@@ -153,6 +158,9 @@ export const EXPLORER = {
     linkAlpha: 0.2,
     hubLabels: 18,
     hubLabelHeight: 24,
+    /** Domain names across each galaxy (A93b): height in scene units, opacity per theme. */
+    domainLabelHeight: 110,
+    domainLabelAlpha: { dark: 0.26, light: 0.3 },
     /** Minimum distance between terms (see `spacing`), in scene units. */
     labelClearance: 10,
     /**
diff --git a/app/src/lib/graph-layout.test.ts b/app/src/lib/graph-layout.test.ts
index 6f330b76..7ae57afe 100644
--- a/app/src/lib/graph-layout.test.ts
+++ b/app/src/lib/graph-layout.test.ts
@@ -163,6 +163,29 @@ describe('backboneOf', () => {
     expect(backboneOf(nodes, links, new Set(['association', 'contrast'])).has(4)).toBe(false);
     expect([...backboneOf(nodes, links, new Set(['contrast']))]).toEqual([4]);
   });
+  it('strands no visible term: hide AI and data poisoning keeps a visible edge', () => {
+    const t = (id: string, domain: string[]) => ({ id, domain, cluster: 'k' });
+    const terms = [
+      t('ai/data-poisoning', ['ai', 'security']),
+      t('ai/training-data', ['ai']),
+      t('ai/model-training', ['ai']),
+      t('ai/prompt-injection', ['ai', 'security']),
+      t('ai/llm', ['ai']),
+      t('ai/jailbreak', ['ai']),
+    ];
+    const edges = [
+      L('ai/data-poisoning', 'ai/training-data', 6.3, 'security'),
+      L('ai/data-poisoning', 'ai/model-training', 5.9, 'dependency'),
+      L('ai/data-poisoning', 'ai/prompt-injection', 2.8, 'security'),
+      L('ai/prompt-injection', 'ai/llm', 9, 'security'),
+      L('ai/prompt-injection', 'ai/jailbreak', 9, 'security'),
+    ];
+    const types = new Set(['security', 'dependency']);
+    // Over the whole graph its two slots go to AI-only terms: hidden with AI off.
+    expect(backboneOf(terms, edges, types).has(2)).toBe(false);
+    const securityOnly = new Set(['ai/data-poisoning', 'ai/prompt-injection']);
+    expect([...backboneOf(terms, edges, types, securityOnly)]).toEqual([2]);
+  });
 });
 
 describe('OVERVIEW_FAMILIES (A95)', () => {
diff --git a/app/src/lib/graph-layout.ts b/app/src/lib/graph-layout.ts
index 334ed042..d61165fb 100644
--- a/app/src/lib/graph-layout.ts
+++ b/app/src/lib/graph-layout.ts
@@ -141,15 +141,20 @@ export const OVERVIEW_FAMILIES: ReadonlySet<string> = new Set([
  * The backbone over only the relationship families switched on (by default the
  * overview's, `OVERVIEW_FAMILIES`), as indices into the full `links`: a family that is
  * off no longer takes a term's strongest-link slots, so the families left on fill them.
+ * Given the `visible` terms, it is computed over them alone: a term whose strongest links
+ * went to hidden terms keeps its strongest visible one, so no connected term is stranded.
  */
 export function backboneOf(
   nodes: Node[],
   links: (WeightedLink & { type?: string; primary?: boolean })[],
   families: ReadonlySet<string> = OVERVIEW_FAMILIES,
+  visible?: ReadonlySet<string>,
 ): Set<number> {
-  const on = links.flatMap((l, i) => (families.has(l.family) ? [i] : []));
+  const on = links.flatMap((l, i) =>
+    families.has(l.family) && (!visible || linkVisible(l, visible)) ? [i] : [],
+  );
   const chosen = backbone(
-    nodes,
+    visible ? nodes.filter((n) => visible.has(n.id)) : nodes,
     on.map((i) => links[i]),
   );
   return new Set([...chosen].map((j) => on[j]));
diff --git a/app/src/pages/[lang]/explorer/index.astro b/app/src/pages/[lang]/explorer/index.astro
index 5695b221..b3d30c7f 100644
--- a/app/src/pages/[lang]/explorer/index.astro
+++ b/app/src/pages/[lang]/explorer/index.astro
@@ -57,8 +57,31 @@ const about = aboutProps(lang);
    * The About button (A84) owns the map's top-right corner; the floating control bar
    * (A93) is centred between insets that keep it clear of the button.
    */
+  /*
+   * The legend scales with the screen (A93b): a wider collapsed pill on big screens and a
+   * wider open box. The bar's left inset follows it (`--xp-legend[-open]`), so the two
+   * never meet; the right inset keeps the About "i" clear.
+   */
   #explorer {
     position: relative;
+    --xp-legend-w: clamp(18rem, 22vw, 28rem);
+    --xp-legend: 9rem;
+    --xp-legend-open: calc(var(--xp-legend-w) + 1.5rem);
+  }
+  #explorer [data-explorer-legend] details[open] {
+    width: var(--xp-legend-w);
+  }
+  @media (min-width: 1440px) {
+    #explorer {
+      --xp-legend: 11.5rem;
+    }
+    #explorer [data-explorer-legend] details:not([open]) {
+      min-width: 10rem;
+      padding-block: 0.625rem;
+    }
+    #explorer [data-explorer-legend] summary {
+      font-size: 0.8125rem;
+    }
   }
   #explorer [data-about-corner] {
     transition:
diff --git a/design/AUTONOMOUS_DECISIONS.md b/design/AUTONOMOUS_DECISIONS.md
index 48855835..1c35cc78 100644
--- a/design/AUTONOMOUS_DECISIONS.md
+++ b/design/AUTONOMOUS_DECISIONS.md
@@ -151,6 +151,7 @@ Closed Vocabulary lint (E1) + full rule set; GitHub Pages deploy.
 | A92 | **Light theme, theme + language menus, footer at the bottom, sign-in-first account page.** (1) **Semantic tokens** in `global.css` (`--bg`, `--surface`, `--surface-2`, `--border`, `--border-strong`, `--border-hover`, `--fg`, `--fg-soft`, `--muted`, `--subtle`, `--accent`, `--focus`) with dark and light values, exposed through `@theme inline` as `bg-bg`, `text-fg`, `border-border`, `text-accent`…; every `neutral-*`/`white` class outside the map files was mapped mechanically (950→bg, 900→surface, 800/700→surface-2; text 50/100→fg, 200/300→fg-soft, 400→muted, 500/600→subtle), status colours got light values plus `dark:` variants. `dark:` is a custom variant keyed on `data-theme="dark"` (OS preference when there is no attribute, i.e. no JavaScript). Dark values keep the old look except `subtle` (#737373 → #909090) and the focus ring, which now meet AA. Every text token is ≥ 4.5:1 on bg/surface/surface-2 in both themes (worst 4.74). (2) **Choice**: header sun/moon menu, System / Light / Dark (`role="menuitemradio"`); System (the default) follows `prefers-color-scheme` live; Light/Dark stored as `atlas.theme` (listed on the privacy page, EN/DA). **No flash**: `public/theme-init.js`, a blocking `<script src>` as the first child of `<body>` — not in `<head>`, because Astro appends the CSP meta at the end of `<head>` and dist-guard (rightly) refuses any script before the policy; an external file needs no hash under `script-src 'self'`. Logic mirrored and unit-tested in `prefs.ts` (`parseTheme`, `resolveTheme`). (3) **Night map**: the Explorer, the canvas lab, the timeline chart and the term page's connection graph sit in a `data-theme="dark"` container, so they stay dark in the light theme (tokens hang off the attribute selector, so nesting re-scopes them); `Explorer.tsx`, `CanvasExplorer.tsx`, `Graph.tsx`, `GraphLegend.tsx`, `Timeline.tsx` and `explorer-*`/`graph-*` keep their literal dark classes — another agent owned them, and a light map canvas needs its own design pass (edge/label colours tuned for dark). **Superseded (owner request, PR feat/light-theme-complete): the night-map rule is gone.** The maps follow the page theme: in the light theme they sit on a warm cream ground (`--map-bg` #f6f1e7, `--map-glow` #faf6ee, a radial vignette via `.map-surface`) and every map element has a light-theme style. `graph-style.ts` gains `MapTheme` and `MAP_INK` (labels dark with a cream halo, ticks, selection, 3D background and fog, soft shadow instead of glow, flow-dot opacity) and a `theme` parameter (default dark, so server callers and tests are unchanged) on `domainColour`, `clusterColour`, `nodePaint`, `legendDomains`, `edgePaint`, `effectivePaint`, `domainBands`; cream shades are the same hues, deeper, darkened step by step until they reach 4.5:1 on cream (domains, also used as text) or 3:1 (clusters, WCAG 1.4.11); family colours have `FAMILY_COLOURS_LIGHT`. The theme is read from `data-theme` (`currentTheme`/`watchTheme` in `graph-cytoscape.ts`, the `useTheme` hook) and switches live, with no reload and no relayout: `retheme()` on the 2D and 3D maps swaps the stylesheet and element colour data (3D: background, fog, labels, and the additive glow, web and comets become multiplied tints, since light added to cream is invisible); the term graph and the canvas lab restyle in place. The timeline is server-rendered, so its domain colours are CSS custom properties (`.map-ink`: `--ink-d`/`--ink-l`) that follow the theme before hydration. Nav bar, control bar, legend, popovers, hover card and panels are on the A92 tokens. Domain-name watermarks on the 2D map stay decorative (0.45 opacity) and are not held to AA. **Scope narrowed (owner follow-up, PR fix/theme-scope-and-credits):** cream is only the Explorer's void (2D and 3D) and the canvas lab; the timeline chart and the term-page graph use the normal light surface (`--chart-bg` = `--surface` #f5f5f5, `.chart-surface`) with the same light palette, and stay the night map in the dark theme. The page and surface tokens are the A92 ones, unchanged. (4) **Language menu**: button + `role="menu"` of links (inline SVG flags — Windows renders flag emoji as letters — plus "English"/"Dansk"), same page via `swapLang`, arrows/Home/End/Esc/Tab, `#lang-switch` id kept for the tour. (5) **Footer**: body is a min-h-screen flex column, `main` flex-1 (wide pages unchanged). (6) **Account page signed out = the sign-in page**: heading "Sign in to Atlas", why, full-width provider buttons; the privacy link and "Download my progress" follow. OAuth already returned to the account page and the header "Sign in" already linked there. (7) Explorer sidebar: the selected-term card (cluster, name, summary) is gone — the term panel shows the same; its map actions (prerequisites, neighbourhood, expand, whole map) stay. | Owner requests. Tokens instead of a remapped neutral palette so the names say what a colour is for. |
 | A93 | **Explorer: a floating control bar instead of the sidebar** (owner decision; amends A86's *Sidebar* follow-up). The map is full width. **Bar**: one rounded, centred row floating over the top of the map, styled after the canvas lab's toolbar, inset `left-14 right-14` so it never touches the edges or the About "i" (which keeps the top-right corner and still glides left of the docked term panel; the bar's right inset moves with it). It holds 2D/3D; Force/By depth/By time (2D) or **Auto-rotate** (3D, new: OrbitControls `autoRotate`, `EXPLORER.three.spinSpeed`, off by default and never under reduced motion); the domain toggles as pills; popovers for **Relationships** ("Show all relationships", the overview note and the family checkboxes), **Colour by** (Cluster / My knowledge) and **Route** (From/To, Find route, Clear, the route); and **Find a term** (`searchTerms` from `canvas-explorer.ts`; picking a term turns its domain on, leaves the time layout if it is undated, and selects it). One popover is open at a time; Esc closes it and returns focus to its button, as does a press outside the bar; the term panel's Esc handler stands down while a `[data-map-popover]` is open. The layout's note sits under the bar. Below 768 px the bar condenses to 2D/3D and a **Controls** sheet holding everything (rendered once, never duplicated). `role="group"`, `aria-pressed` toggles, `aria-expanded`/`aria-controls` on popover buttons. **Legend**: its own floating, collapsible box bottom-left (clear of the beta ribbon), still collapsed on a first visit and remembered in `atlas.explorer.legend` (no new storage keys). **Term panel actions**: the sidebar's selected-term card is gone; "Show prerequisites", "Neighbourhood", "Expand +1" and "Whole map" are a row of buttons under the panel's toolbar (`actions` prop; the lab's panel has none). **Hover card**: with a mouse (`(hover: hover) and (pointer: fine)`, so never on touch), resting on a term for 1.2 s (`EXPLORER.hoverCardMs`) shows a small card beside it — name, cluster chip, domain, and the summary already in graph.json (no fetch). Moving off, pressing, panning, zooming, orbiting or switching view hides it; 2D/3D report the term's screen position through a new `onPoint` callback; no card while auto-rotating (terms drift under the pointer). **Tour**: the three Explorer steps keep their `data-tour` anchors on the bar (layouts on 2D/3D, filters on the domain pills, route on the Route button) and fall back to `[data-explorer-bar]`. **Measured** (headless Edge, 1440×900, 2× CPU throttle): 2D pan ≈50 fps (47–50 over three runs), zoom 57, hover 59; 3D 60. | The owner likes the lab's floating toolbar: the map gets the whole width and the controls stay one slim row. Popovers keep parity with the sidebar without widening the bar. |
 | A93a | **Explorer layout fix** (owner, amends A93): the legend moves to the map's top-left corner, level with the bar (collapsed to a pill, drops down to 60vh when open), and the bar is centred between equal `md:left-36 md:right-36` insets that clear it (sized for the Danish "Forklaring") and the About "i"; on phones the bar drops below the pill; the bar no longer moves when the term panel opens (only the "i" slides), the panel simply sits above it. **Colour by** is an inline Cluster | My knowledge toggle in the bar (no popover), so the bar never changes size. **Relationship types filter the overview only**: a selected term always shows all its relationships (2D, 3D and its neighbourhood); every type starts on except *used with* (amended by A95: contrasts and alternatives start off too); the backbone is recomputed over the types switched on (`backboneOf`), so an off type no longer takes a term's strongest-link slots; one line in the Relationships popover says so. The term panel keeps a single "Read more" (its toolbar). **One-row bar** (≈720 px at 1440): domain toggles are dot-only chips (name in tooltip and aria-label; labelled in the phone sheet), tighter segments, a short "Links" button, and "Find a term" is a search icon that opens the field (Esc or blur when empty closes it). With the panel docked the "i" also drops below the bar row, so it never covers the bar; while the legend is open the bar sits right of it (`md:left-[18rem]`), and on phones the legend sits below the bar. | The legend looked adrift mid-left; a bar that jumps when a term opens is disorienting. |
+| A93b | **Explorer UX pass** (owner, 2560×1440 feedback; amends A93a). **Responsive bar**: the one-row bar is measured, not fixed (a ResizeObserver on the space between the legend and the "i", then a before-paint check of the bar's in-flow width, so an open popover or result list never shrinks it): *full* — domain pills with names, the "Find a term" field open, "Relationships"; *medium* — dot-only domain chips; *compact* — the old "Links" and search icon; and when even that would wrap, the phones' "Controls" sheet. Never two rows; it restarts from full when the space, the 2D/3D mode, the legend or the language changes. **Legend**: collapsed at least 10rem wide from 1440 px (the bar's left inset `--xp-legend` follows: 9rem, 11.5rem from 1440), open `clamp(18rem, 22vw, 28rem)` (inset `--xp-legend-open` = that + 1.5rem). **3D domain names**: each domain's name in its colour, large and faint (`three.domainLabelHeight/domainLabelAlpha`), a billboarded sprite just above its galaxy; hidden with the domain, fainter while a term is hovered, selected or routed, redrawn on a theme switch; not a 3d-force-graph object, so it never takes a click. **No stranded terms**: the backbone is computed over the terms shown (`backboneOf(…, visible)`, 2D and 3D, recomputed when the shown set changes), so a term whose strongest links went to a hidden domain keeps its strongest visible one among the types switched on (tested). **Toggle hitching**: 2D works out edge classes in plain data and touches only edges whose classes change; a toggle that changes more than `motion.revealBatch` (120) edges applies them a batch per frame (bundled routes with them), a smaller one fades in at once; 3D skips re-evaluating 3d-force-graph's accessors when only types or "show all" changed with nothing focused, and reveals the web a batch per frame. All instant under reduced motion. Longest frame at 2× CPU throttle, 1440×900 (two runs each): 2D "show all" on 700–735 → 150 ms, off 420–585 → 117–134 ms, a type on 280–550 → 100–134 ms; 3D "show all" on 430–820 → 134–150 ms, a type on 230–500 → 117–200 ms; switching off one type is unchanged (~50–80 ms). Pan, zoom, orbit and idle fps unchanged. The light theme's cream void was a stale cache (owner), verified live in 2D and 3D. | The bar was minified on a 2560 px screen with room to spare; the legend was a small pill; the 3D galaxies were unnamed; toggling types froze the map for half a second; a security term looked orphaned with AI off. |
 | A94 | **No em or en dashes anywhere a reader sees them** (owner rule). Every U+2014 em dash, U+2013 en dash and U+2015 horizontal bar in terms (all fields), articles, the question bank and the UI strings (`site.ts`, `privacy.ts`, `ui-extra.ts`, page titles " - Atlas", the empty-value placeholder, screen-reader announcements, inline page text) became hyphen-minus: " - " between clauses, "2018-2020" in ranges, "-" as a placeholder. The swap was mechanical (one character for one, verified by re-parsing every YAML file and frontmatter and checking no Markdown line turned into a list item or rule), not a per-sentence rewrite. **Guards**: lint **E12** fails on any of the three in a `src/content/**/*.{yaml,md}` file (raw text, so every field counts), and `ui-strings.test.ts` walks the exported values of `site`, `privacy`, `ui-extra`, `about` and `tour` (values, not source, so code comments may keep theirs). Components and pages are not unit-scanned; the Explorer files being reworked at the time (`Explorer.tsx`, `GraphLegend.tsx`, `AboutButton.tsx`, `explorer/index.astro`) are a follow-up. | The owner wants only normal dashes. One-for-one replacement keeps the diff reviewable and the text meaning intact; a lint rule and a string test stop them creeping back in from authoring tools that auto-convert "--". |
 | A95 | **Explorer overview types, meaning search in "Find a term", drag feedback** (owner-approved types; amends A93a). **Overview**: with nothing selected the map draws only kind-of, part-of, implements, requires, mitigates, exploits, causes, mandates and supersedes (`OVERVIEW_FAMILIES` in graph-layout.ts = the structure, dependency, security, regulation and lineage families; `backboneOf`'s default). *Used with*, *contrasts with* and *alternative to* start unticked in the Relationships popover (its one line says which types the overview starts with, EN+DA); a selected term still shows all its relationships. **Find a term** behaves like the home search: instant name and alias matches (aliases now ride in `graph.json` when a term has any), and for a question or description the `semantic-search` function's near-best hits, fused by RRF and labelled "by meaning"; the debounced, abortable client is one hook (`use-semantic.ts`) and the fusion one pure function (`mergeHits`), both shared with the home search; without a backend, or on failure or timeout, names only. Picking a result selects the term and brings it into view (also when it is already selected; the 3D camera cuts instead of gliding under reduced motion). **Drag feedback** (`drag-feedback.ts`): an open hand at rest, a closed hand while panning (2D, 3D right or modified drag), a light rotate-arrow cursor while orbiting (3D), and a light ring with a crosshair and a dark outline following the mouse while dragging (not on touch; no fade under reduced motion); Cytoscape's dark press disc is switched off. Tunables in `EXPLORER.drag`. **About "i"**: hidden while the term panel is expanded, so it never covers the panel's own controls. | The overview read as a hairball of symmetric links; the owner picked the types that carry structure. A search box that only knew names disagreed with the home search. The old press marker was a dark disc on a dark map: dragging gave no visible feedback. |
 | A96 | **A hidden visual lab for the Explorer** at `/<lang>/lab/5f69d757b126/2d/` and `/3d/` (EN + DA; noindex so out of the sitemap, linked from nowhere, no tour, like A91), so the owner can see and measure old visual effects live without deploying test branches. Each page renders the real `Explorer` (bar, legend, About "i", term panel unchanged) and a floating **Lab** panel whose toggles restyle in place, never relayout. **2D**: backbone curve (straight haystack, today / bezier / unbundled-bezier from the edge's own offset × a strength slider), source-to-target domain-colour gradients, one-way flow (overlay dots, today / the old Cytoscape `line-dash-offset` marching dashes on every visible one-way edge / none) with a speed slider, hover (today / the old `attachHover` that restyles every element, plus the old fade transitions), node glow, "show all", label density (none / hubs / culled, today / all) and the viewport snapshot. **3D**: merged lines (today) or a tube and arrow cone per link (old), link curvature (re-bends the merged web and the comets too), flow (comets, today / the old per-link particles / none) with speed, glow (point cloud, today / a sprite per term, old), bloom (`UnrealBloomPass` + `OutputPass` and an opaque scene background, else the transparent canvas turns grey), auto-rotate, fog, node spacing (the scene scales about its centre while terms and labels keep their size). **Meter**: rAF-based, current fps, 1% low (1000 / 99th-percentile frame time) and the longest frame over the last 5 s; **Benchmark** runs a scripted 5 s pan and zoom (2D, straight through `cy.viewport`, so every frame is a full redraw: the snapshot only applies to user gestures) or one orbit (3D) and reports the average fps and the active toggles. Toggles start from the address (`?curve=bezier&gradient=1&bench=1`), so a headless run is a list of URLs; nothing is stored (no new storage keys). **Production hook, optional and inert by default**: `Explorer` takes `lab?: { mode, showAll, onMaps }`; `createMap2D` returns `lab.dots` (a live copy of `EXPLORER.dots`) and `setDots`, `startDots` takes that copy; `createMap3D` returns `lab` (its three.js objects, the flow settings copy, the curve buffer and its link predicates). Old effects live in `ExplorerLab.tsx` / `explorer-lab.ts`, not behind production flags. **Measured** (headless Edge, 1440×900, 2× CPU throttle, RTX 3080; the PR has the table): 2D scripted pan and zoom (full redraws) ≈13 fps today, curves or gradients ≈11, marching dashes ≈9, all three ≈7, "show all" + dashes ≈5, no flow ≈16; 3D orbit 60 today, tubes ≈13, per-link particles ≈25, sprite glow ≈33, bloom 59 (1% low 30), tubes + particles + sprites ≈8. **Later additions (owner)**: the lab follows the page theme through the maps' own `retheme` (it re-reads the restyled base and lays its rules over it again; bloom is off on the cream map, where it only washes out); **emphasis by importance** (both views): importance = a per-type rank (requires, kind of, part of 1.0; mitigates, exploits, causes, mandates 0.85; implements, supersedes 0.7; contrasts with, alternative to 0.5; used with 0.35) × the square root of the link's own `weight` normalised to the heaviest, shown as opacity, colour (saturation and lightness towards the background), width (2D and 3D tubes) or all three, with a spread slider (importance ^ spread); **relayout** (lab only): a minimum-distance slider that re-runs the spacing pass (`createMap2D` keeps each island's fcose result and exposes `lab.relayout`; 3D re-spaces from the original layout) and sub-domain clusters (2D: islands 0.8 × and 70 px further apart; 3D: clusters 1.4 × out from their domain's centre and 0.7 × tighter, with optional faint cluster names); **cream-map contrast** sliders (term saturation / lightness, edge darkness / opacity, shadow strength, 2D label weight / halo) with a "Copy values" button. 3D exposes inert `webGain` / `webTint` per link, `linkLength`, `radius` and `labels` for these. | The owner wants to judge effects by eye and by frame rate before choosing; a lab that reuses the real component measures the real cost, and keeping the old code paths out of production keeps the Explorer diff to a few inert lines. |