← All tests

React Flow — Muse Map graph

Full Muse Map v5 dataset (130 nodes) as an operational graph

2026-11-19FINDS - TESTSFind #74 (React Flow)

Try it

Live demo

Report

React Flow vs hand-built My Muse Map — head-to-head report

Track B, FINDS - TESTS slate 2. Built and verified 2026-11-19 (PT). The live Muse Map app was not modified; this is a standalone prototype in app/.

Dataset used + reconciliation

Source: the full job-level v5 dataset, extracted from the live map itself. The My Muse Map (slug my-muse-map, static Space) embeds its entire audit dataset as a var DATA = [...] literal in ~/workspace/ts-spaces/my-muse-map/index.html (line 296, re-audited Nov 19, 2026 · 5:51 PM PT). extract-data.mjs evals that literal and slims it to dept/team/job names, statuses, team chat lists, and job home chats → map-data.json (copied into the app as app/src/data.json). No fallback was needed; the Archify v5 spec was not used.

Reconciliation — exact, no flags:

Level Expected (v5) Extracted Rendered in app (DOM count)
Departments 8 8 8
Teams 36 36 36
Jobs 85 85 85
Statuses Live 8 / Assisted 67 / Gap 10 Live 8 / Assisted 67 / Gap 10 —
Total nodes 130 (1 root + 8 + 36 + 85) — 130
Edges 129 — 129

Per-department jobs: Health & Body 8 · Money & Admin 11 · Career 10 · Family & Legal 4 · Builds & Code 16 · Knowledge & Finds 19 · Home & Gear 6 · Brain & Memory 11 = 85.

What was built

  • Stack: Vite (React template) + @xyflow/react 13.0.2 + dagre 0.8.5. npm run build passes (only upstream rolldown chunk-size / directive warnings). Built bundle ~596 KB in app/dist.
  • Graph: root "The Brain — My Muse" → 8 department nodes → 36 team nodes → 85 job nodes, dagre left-to-right tree layout, re-run on every collapse/expand.
  • Files / LOC: app/src/App.jsx 207 lines (graph model, layout, custom node, HUD, detail panel — everything), app/src/App.css 60 lines, index.css 2 lines, template main.jsx 10 lines. Plus extract-data.mjs (31) and the screenshot harness app/screenshot.mjs (35). The whole interactive graph app is effectively one 207-line file + 60 lines of CSS.
  • Styling language mirrors the hand-built map: Live = filled cream with copper/amber border, Assisted = neutral white/grey, Gap = hollow, dashed, dimmed to 62%. Root is a dark "Brain" node; departments are heavier-bordered containers of the tree.

Effort (honest log)

  • Data discovery + extraction: ~10 min. One failed inline node -e (syntax error in a one-liner) → rewrote as extract-data.mjs, worked immediately. Counts reconciled on first successful run.
  • Scaffold + installs: ~40 s, zero errors (npm create vite, @xyflow/react, dagre).
  • App code: written in one pass; npm run build passed on the first attempt. The graph model, collapse logic, and detail panel needed no debugging.
  • Screenshot/verification phase: 5 iterations, and the friction was in my harness, not React Flow —
  • screenshot script placed outside app/ → playwright-core not resolvable (module resolution follows the script, not cwd);
  • a sed patch collided with the script's own URL identifier;
  • the task brief's chromium-1255 path doesn't exist on this box — chromium-1254 does (used that, with --no-sandbox via playwright-core's executablePath, no wrapper needed);
  • Playwright's dblclick() actionability checks fail at ~0.1 zoom (node is 21 px wide, viewport transform fights scroll-into-view) → switched to raw page.mouse.dblclick at the node's bounding-box centre;
  • first screenshots were pure white — root cause was my own bug: the rewritten App.jsx dropped the template's import './App.css', so .app-shell/.react-flow collapsed to height 0 and clipped everything. One-line fix, rebuild, all shots good.
  • Total wall-clock for the build + verification loop: roughly 45 minutes, most of it the screenshot harness.

Interaction inventory — free vs hand-written

Came free from React Flow (zero or one-line cost): - Pan / zoom (mouse, wheel, pinch), zoom-to-cursor - Controls (zoom in/out, fit-view, lock) — one component - MiniMap (pannable + zoomable) — one component - Background dot grid — one component - Node selection highlight, node dragging, edge rendering (clean bezier fans), fitView incl. fit-to-a-set-of-nodes (powers the double-click focus), viewport animation

Hand-written (all small): - The data flattening (DATA → node records with parent links), ~30 lines - Dagre layout glue, ~20 lines (React Flow does not lay out trees for you — this is the one real gap an agent must fill, and dagre fills it in a dozen lines) - One custom node component (name + meta + collapse toggle button), ~25 lines - Collapse/expand state + visible-subtree computation + re-layout, ~25 lines - Click detail panel (name, kind, status, parent, home chat / team chats, child count), ~20 lines of JSX - Status styling, ~15 lines of CSS

Nothing in the "hand-written" list was hard or library-specific; it's the same glue any graph UI needs.

Legibility verdict (from the screenshots)

  • screenshot-full.png — all 130 nodes fitted at 1600×900: illegible. Fit zoom is ≈0.10; the LR tree is only 4 ranks wide but ~85 jobs tall, so the graph renders as a narrow vertical strip using ~15% of the viewport width, with labels at 1–2 px. Zero label overlap and zero edge crossings (it's a tree — dagre's fan-out is clean), and the cream Live nodes read as colour accents, so the shape communicates (8 dept clusters, where the Live jobs sit) — but no word can be read. As an overview it is a texture, not a map.
  • screenshot-collapsed.png — "Collapse all teams" (130 → 45 nodes): better, still not legible at fit. Department names are readable, team names are ~5 px and squinted-at best. Collapse helps navigation, it does not make the full graph fit-to-screen readable, because the tree's problem is height, not density.
  • screenshot-department.png / screenshot-detail.png — at department zoom, fully legible. Double-clicking Knowledge & Finds (6 teams, 19 jobs — the largest department) fits its subtree at a zoom where every job label, status line, and team chat list is crisp; no overlaps, no crossings, edges trace cleanly from dept → team → job. The detail panel for the FINDS - TESTS job shows name, status, parent team, and home chat correctly. This focus-and-inspect mode is where React Flow is genuinely good.

Net legibility answer: collapse is necessary but not sufficient; the working pattern is collapse + focus-zoom per department, exactly the interaction the hand-built map already implements in its own way (overview → fan into one department → tap a job). React Flow does not magically solve 130 nodes on one screen — nobody does — but its built-in fit-to-subtree makes the focus step one double-click with animation, for free.

Draft verdict

For the My Muse Map itself: tie leaning lose — do not rebuild the live map on React Flow. The hand-built map's radial "galaxy" overview (Brain at centre, departments orbiting, one department fanned at a time) is a deliberate, bespoke answer to the same legibility wall, and it doubles as a designed one-page document (ledger, search, status filters, the SkillTree look Ros chose). The React Flow tree gives up that identity and the document qualities, and at full fit it's less legible than the radial overview (a skinny strip vs a composed galaxy). What React Flow would save in maintenance is real but small — the map changes a few times a month via re-audit, and its data is a static literal either way.

For the Orchestrator's job-routing view (secondary subject): React Flow wins, clearly. That view is an operational graph, not a document: live routing between chats/agents, paths to trace, subtrees to collapse when a branch is stuck, nodes to click for state. Pan/zoom, minimap, collapse, fit-to-subtree, and click detail are precisely its requirements, and this prototype shows an agent can stand the whole thing up in ~270 lines with the interaction layer essentially free. If the Orchestrator gets a UI, build it on React Flow.

Generalised: React Flow is the right default for working node graphs (operational, explored by zooming and collapsing) and the wrong tool for presentational one-page maps (composed, read at a glance). Effort is not a differentiator — the build was one file, one pass; the library's value is the interaction layer, not code savings.

Test record

  • Subject: React Flow (@xyflow/react 13.0.2) vs the hand-built My Muse Map graph view
  • Date: 2026-11-19
  • What: Built a standalone Vite + React Flow + dagre prototype of the Muse Map graph on the full v5 dataset extracted from the live map's own index.html (130 nodes / 129 edges, reconciled exactly: 8 depts, 36 teams, 85 jobs, Live 8 / Assisted 67 / Gap 10), with pan/zoom, MiniMap, Controls, map-language status styling, subtree collapse/expand, double-click focus, and click detail. npm run build passes; rendered DOM verified at 130 nodes / 129 edges; collapse verified 130 → 45 nodes; screenshots at full fit, collapsed, department zoom, and job detail (Playwright, chromium-1254, 1600×900).
  • Outcome: Success as a test. Interaction layer essentially free; graph code one 207-line file, written in one pass. Full-fit view illegible (zoom ≈0.10, tall skinny tree) — collapse + per-department focus is required, where it becomes fully legible with zero overlaps/crossings.
  • Output: This report + app/ (source and built dist) + map-data.json + screenshot-full.png, screenshot-collapsed.png, screenshot-department.png, screenshot-detail.png, all in ~/workspace/finds-tests/react-flow-muse-map-2026-11-19/
  • Reuse status proposal: Reuse later — for the Orchestrator job-routing view (build on React Flow if/when that UI happens). Not adopted for the Muse Map itself; the hand-built radial map stays.

Screenshots & outputs