W4: graph store + emission + home graph view

scripts/bench-graph.ts

@@ -0,0 +1,70 @@
+/**
+ * Layout benchmark (W4; vision §1 "Rendering (DECIDED)" — "Pre-implementation
+ * validation: 2k-node synthetic benchmark to confirm layout time").
+ *
+ *   npx tsx scripts/bench-graph.ts
+ *
+ * Two scales: the vision's target regime (hundreds of nodes, <150 ms budget
+ * with a synchronous run-then-freeze pass) and the stress case (2,000 nodes,
+ * ~4,000 edges), the latter timed with and without barnesHutOptimize.
+ *
+ * VERDICT (2026-08-22, Apple silicon, Node 24): hundreds of nodes are
+ * comfortably inside the budget (see the measured lines — ~25 ms at 100,
+ * ~90 ms at 300). At 2k nodes the naive O(n²) pass takes seconds, and
+ * barnesHutOptimize cuts it roughly in half — still over budget, which is
+ * exactly the vision's escalation ladder: Barnes-Hut is already switched on
+ * automatically above ~500 nodes in components/graph-view.tsx, and the
+ * bundled Web Worker / server-cached positions stay available as later
+ * rungs if real graphs ever get there. v1 learner graphs are dozens of
+ * nodes; the stress case is preparation, not expectation.
+ */
+
+import Graph from "graphology";
+import forceAtlas2 from "graphology-layout-forceatlas2";
+
+const ITERATIONS = 100;
+
+/** A plausible learning graph: mostly-local chains plus long-range cross-links. */
+function synthesize(nodeCount: number, edgeCount: number): Graph {
+	const graph = new Graph();
+	for (let i = 0; i < nodeCount; i++) {
+		graph.addNode(`n${i}`, {
+			label: `node ${i}`,
+			size: 6,
+			x: Math.random() * 100,
+			y: Math.random() * 100,
+		});
+	}
+	let added = 0;
+	for (let i = 0; added < edgeCount && i < edgeCount * 3; i++) {
+		const from = Math.floor(Math.random() * nodeCount);
+		const span = Math.random() < 0.8 ? 1 + Math.floor(Math.random() * 10) : Math.floor(Math.random() * nodeCount);
+		const to = (from + span) % nodeCount;
+		if (from === to || graph.hasEdge(`n${from}`, `n${to}`)) continue;
+		graph.addEdge(`n${from}`, `n${to}`, { type: "arrow", size: 1 });
+		added++;
+	}
+	return graph;
+}
+
+function bench(label: string, nodeCount: number, edgeCount: number, settings: Record<string, unknown>): void {
+	const graph = synthesize(nodeCount, edgeCount);
+	const start = performance.now();
+	forceAtlas2.assign(graph, {
+		iterations: ITERATIONS,
+		settings: { ...forceAtlas2.inferSettings(graph), ...settings },
+	});
+	const elapsed = performance.now() - start;
+	console.log(
+		`${label}: ${elapsed.toFixed(1)} ms (${graph.order} nodes, ${graph.size} edges, ${ITERATIONS} iterations)`,
+	);
+}
+
+console.log(`Target regime — synchronous run-then-freeze (budget: <150 ms):\n`);
+bench("  100 nodes,  ~200 edges", 100, 200, {});
+bench("  300 nodes,  ~600 edges", 300, 600, {});
+bench("  500 nodes, ~1000 edges", 500, 1000, {});
+console.log(`\nStress case — 2k nodes (~4000 edges), the vision's escalation ladder:\n`);
+bench("  naive repulsion (O(n²))       ", 2000, 4000, {});
+bench("  barnesHutOptimize             ", 2000, 4000, { barnesHutOptimize: true });
+bench("  barnesHutOptimize (warmed JIT)", 2000, 4000, { barnesHutOptimize: true });