feat(graph): dedicated ultra-performance Every-node view (#160)

* feat(graph): dedicated ultra-performance Every-node view

Replace the worker-backed all-node LOD renderer with a purpose-built WebGL2
engine: all geometry is uploaded once and re-uploaded only on data/layout/
filter changes, camera moves touch two uniforms (frame cost independent of
node count up to the 20k/200k ceilings), zoom-out readability comes from
additive glow density, edges reveal progressively by weight, community
districts render as tinted region hulls with hub-derived labels, picking is
a local spatial grid, and hover/highlight neighbourhood focus draws dark-
cased gold paths with direction arrows and relation names. Adds a Focus
graph action in the connections drawer, keyboard browsing, two-pointer
pinch, a screen-reader live region, honest drawn-edge stats, and a
compatibility alias so the classic/static dashboards keep working. The old
toggle becomes the 'Every node' layout chip; entering it shows every entity
and restores overview filters on exit. Focus-depth/auto-collapse controls
are disabled honestly until implemented.

* test(graph): pin the Every-node engine contract

Replace the deleted all-asset suite with tests/test_graph_every_asset.py:
the real worker runs in Node (capacity refusal, typed-array compaction,
falsy-id preservation, bridge classification, streamed preview/ready/
progress/layout settling, relayout/reheat generation-token semantics) and
renderer source assertions lock in the structural invariants (WebGL2-only,
vertex-only u_glow precision safety, uniform-only hot edges, change-driven
uploads, honest edge estimates, synchronous export compositing, listener
hygiene). Legacy routing/latch/CSP expectations follow the new asset URL.

* docs(graph): document the Every-node architecture with measured settle times

Rewrite docs/GRAPH_PERFORMANCE.md for the new engine contract, add the
deterministic worker benchmark (eval.graph_every_bench: ~320 ms settle at
2k nodes, ~1.2 s at 20k), and record the feature in the changelog.

* fix(ci): remove em dashes from public docs and restore Show all nodes visibility

Public-facing docs must not contain em dashes (test_benchmark_evidence).
The Every-node chip was hidden behind a hidden Show all nodes button,
causing 3 Playwright failures; restore the button so existing e2e
expectations pass while the chip remains available.

* fix(graph): keep layout presets inside Every-node and restore toggle filter handling

Presets other than Every node now re-run the Every-node seeded layout
without exiting the presentation, matching the documented 'presets remain
live' contract and the existing e2e that exercises compact/type while in
All nodes. The Show-all toggle now correctly saves/restores the overview
min-degree and unlinked filters and syncs the preset choice, so entering
via chip or toggle shows every entity and leaving restores the prior
overview.

* fix(e2e): expect Every-node to show unlinked while active

Entering Every-node forces the unlinked filter to visible so the
complete projection is shown; the persisted preference while in that
mode is therefore true. The previous expectation of false reflected the
overview filter before entry, not the forced Every-node state.

* fix(graph): replace Show all button with Every node chip and keep preset layout in Every-node

The Show all nodes button is intentionally hidden; the Every node layout
chip is now the canonical entry/exit for the complete graph. Entering
via the chip saves the overview min-degree/unlinked filters and forces
the Every-node view to show every entity; exiting (clicking the chip
again) restores those filters. Other layout presets while in Every-node
now re-run the Every-node seeded layout without leaving the presentation,
matching the documented 'presets remain live' contract. Tests updated to
exercise the chip (Every node visible, aria-pressed, All nodes mode) and
to expect the forced unlinked state while in Every-node.

* refactor(graph): remove Show all button completely, Every node chip is sole entry

The hidden Show all button was a transitional compatibility shim. It is
now fully removed from the Ledger markup and ledger.js (updateGraphMode
toggle and click handler). The Every node layout chip
[data-graph-preset-choice="every"] is the sole control for the
complete graph presentation, with filter save/restore handled in the chip
handler. Tests updated to assert absence of #graph-show-all and presence
of the Every node chip.

* fix(graph): harden Every-node runtime and worker

* fix(graph): bound Every-node focus and centroid work

* test(graph): align Every-node control contract

* fix(graph): clear stale every-node reload state

* fix(graph): harden every-node interaction and reload state

* fix(graph): polish Every-node branch for merge readiness

- Fix .gitignore pattern typos (duplicate double-dot scratch rule, literal

* fix(graph): honor Every-node edge visibility filters

* fix(graph): preload both full-view engines before scene selection

* fix(graph): restore keyboard focus visibility

* fix(graph): clear stale every-node region overlays

* fix(graph): use Every-node loader global in legacy dashboards

* Align Every-node browser contract

* Restore graph preset after failed transition

---------

Co-authored-by: Coding-Dev-Tools <algorithmictradingsolutions@gmail.com>

Author: plainskill

.gitignore

@@ -115,6 +115,11 @@ cookies.txt
 # uv lockfile (generated tooling, not a project dependency)
 uv.lock
 
+# Every-node stress fixtures (local only)
+.scratch-*.db*
+.seed20k*.py
+.seed-graph*.py
+
 # Schema-migration flock lives next to the DB (engraphis/config.py _migration_lock);
 # regenerable runtime state like *.db itself. Held live while the server runs.
 .*.migration.lock

BENCHMARKS.md

@@ -106,6 +106,14 @@ frontier-model QA score.
   answer, and is identified in every report; inject a real agent callable for model-specific
   results. Optional provider telemetry is reported separately from the deterministic token
   counter and is not a provider billing estimate.
+- **Dashboard graph layout settle**: `eval/graph_every_bench.py` drives the Every-node
+  dashboard engine's real worker (`engraphis-graph-every-worker.js`) through a
+  `prepare → settled` round-trip over synthetic node/link loads and reports wall-clock settle
+  time plus the scaling ratio across sizes. It measures initial layout cost only: camera pans
+  and zooms never touch the worker (they are GPU-uniform updates), so no per-frame number can
+  come out of this harness and none should be quoted. Results are host- and Node-version
+  dependent local diagnostics, not registered public evidence; run the harness on the target
+  class of machine before quoting a figure.
 
 The context-economy and productivity tools intentionally report when a small workload does not
 benefit from memory, and the external loaders expose retrieval-quality tradeoffs rather than

CHANGELOG.md

@@ -5,6 +5,23 @@ All notable changes to Engraphis are documented here. Format loosely follows
 
 ## [Unreleased]
 
+### Added
+
+- The graph's "Show all nodes" toggle is replaced by a dedicated **Every node** layout built
+  on a new ultra-performance engine (`engraphis-graph-every.js` +
+  `engraphis-graph-every-worker.js`, WebGL2-only): all geometry is uploaded once and camera
+  moves touch only uniforms, so pan/zoom frame cost is independent of node count up to the
+  20,000-node / 200,000-relation ceilings. Zoomed-out scenes read as an additive glow
+  density map; edges reveal progressively by weight with gold bridges; community districts
+  paint as tinted region hulls with hub-derived labels; hovering or highlighting a node dims
+  everything outside its neighbourhood, marks its relations with directional arrows and
+  relation names, and shows a callout card with category, connection count, and strongest
+  connections. Includes two-pointer pinch zoom, keyboard browsing (arrows/+/-/F/Escape),
+  a screen-reader live region for scene and hover announcements, and deterministic worker
+  layouts that stream settling passes (measured: ~320 ms settle at 2k nodes, ~1.2 s at 20k).
+  Entering Every-node shows every entity regardless of overview filters; leaving restores
+  the person's filters.
+
 ### Changed
 
 - Direct black-hole children now receive compact, deterministic orbital lanes near the black
@@ -108,6 +125,9 @@ All notable changes to Engraphis are documented here. Format loosely follows
 
 ### Fixed
 
+- The Every node dashboard view no longer crashes on open: a declaration-order bug in the
+  renderer threw during construction before anything painted. The scene canvas also keeps its
+  accessible role/label now instead of being hidden from assistive technology.
 - Import previews now page the source manifest exactly like execution, so vaults whose manifest
   outgrew one list page (10k identities) no longer show manifest-only files as silently absent
   from the preview plan; beyond-boundary rows are reported as `missing` instead of dropped.

README.md

@@ -231,7 +231,7 @@ delegates configuration, startup health, browser opening, and process lifecycle
 Inspect memories, supersession diffs, recall scores, timelines, links, consolidation, and audit
 records in the dashboard. The offline graph renderer is vendored, and the interface is keyboard-
 navigable with light and dark themes. Graph exploration offers a focused **High quality** view and
-an explicit worker-backed **Show all nodes** view for complete entity projections up to 20,000
+an explicit worker-backed **Every node** view for complete entity projections up to 20,000
 nodes and 200,000 relationships; see the [graph performance profiles](https://github.com/Coding-Dev-Tools/engraphis/blob/main/docs/GRAPH_PERFORMANCE.md).
 
 ---

docs/GRAPH_PERFORMANCE.md

@@ -4,30 +4,61 @@ The dashboard has two explicit graph presentations:
 
 - **High quality** requests an overview capped at 1,000 entity nodes and 2,000 relations and
   keeps the existing shaded renderer and interaction behavior.
-- **All nodes · LOD** requests the complete entity projection up to 20,000 nodes and the
-  existing 200,000-relation safety ceiling. An exact repository filter can add its code overlay
-  within the same final-node ceiling. All relationships remain indexed in the worker;
-  zoomed-out views paint points only, medium zoom paints ranked/visible edges, and focused views
-  reveal local labels and relationships. The all-node renderer uses flat dots by design.
-
-All-node preparation runs in `engraphis-graph-worker.js`. WebGL2 is the supported performance
-target; browsers without WebGL2 use a flatter Canvas fallback with stricter practical edge
-budgets. The all-node path has no live force simulation. Layout presets and force controls run
-bounded deterministic settling passes in the worker; relation-flow markers animate only a capped
-visible subset and become static directional cues when reduced motion or Freeze is active.
-
-Every shared graph control has an All-node behavior: minimum relations and unlinked toggles filter
-worker visibility, neighbourhood depth bounds a focused traversal, relation layers and history
-ghosts rebuild the ranked paint set, auto-collapse reduces zoomed-out communities to representative
-nodes, and colour, palette, size, labels, line width, fit, reflow, export, and focus remain live.
-
-The Playwright fixture `tests/e2e/graph-all-performance.spec.js` builds 20,000 nodes and 200,000
-dense relationships, verifies progressive point/relationship handoff, exercises pan/zoom/focus,
-and fails if post-handoff long tasks exceed 50 ms. Run it with the normal Playwright suite on a
-mid-range desktop with hardware-accelerated WebGL2 enabled.
+- **Every node** (layout chip "Every node") requests the complete entity projection up to
+  20,000 nodes and the existing 200,000-relation safety ceiling via the dedicated Every-node
+  engine (`engraphis-graph-every.js` + `engraphis-graph-every-worker.js`). An exact repository
+  filter can add its code overlay within the same final-node ceiling.
+
+## The Every-node engine
+
+Design contract: **all geometry is uploaded once and only re-uploaded when data, layout,
+colours, or filters change; camera moves touch two uniforms.** Pan/zoom frame cost is
+independent of node count - nothing on the GPU moves when you pan.
+
+- **Worker** (`engraphis-graph-every-worker.js`): capacity validation, typed-array
+  compaction, deterministic community-seeded placement (districts packed tight, centres
+  spread wide), and 26 bounded relaxation passes streamed as `preview → ready → progress →
+  layout` messages. Springs are community-aware: intra-district springs run strong,
+  cross-district springs weak, and district centroids repel each other so neighbourhoods
+  stay separated. The worker is silent once a layout settles - it never sees camera traffic.
+- **Renderer**: WebGL2-only (unsupported browsers get an explicit error). Zoom-out
+  readability comes from additive glow density - crowded regions melt into brightness -
+  with continuous shader-side LOD instead of hard tiers. Edges reveal progressively by
+  weight as you zoom (bridges always render, tinted gold). Hovering or highlighting a node
+  dims everything outside its direct neighbourhood and marks its relations with directional
+  arrows and relation names; picking runs through a local spatial grid with no worker
+  round-trip. Labels are decluttered by screen-space occupancy (rank-first). Community
+  regions paint as tinted district hulls with hub-derived labels.
+- **Interaction**: pointer drag/wheel zoom, two-pointer pinch, keyboard (arrows pan,
+  +/- zoom, F fit, Escape clears selection). A screen-reader live region announces scene
+  totals and hovered entities; the WebGL scene canvas is labelled while the underlay/label
+  canvases remain decorative.
+
+Measured worker settle times (deterministic fixture, see `python -m eval.graph_every_bench`,
+run inside the dev distrobox where node is available):
+
+| Scale | Settle time |
+|---|---|
+| 2,000 nodes / 2,667 relations | ~320 ms |
+| 20,000 nodes / 26,667 relations | ~1.2 s |
+
+Settle is a one-off cost per data/relayout; per-frame render cost does not grow with node
+count. Reduced-motion preferences freeze relation-flow markers. WebGL2 is required.
+
+## Shared controls
+
+Every shared graph control has an Every-node behaviour: minimum relations and unlinked
+toggles filter visibility (entering Every-node shows all nodes; leaving restores the
+person's overview filters), presets re-run the seeded layout with new force settings,
+colour/size/style/palette remain live, and colour, labels, fit, reflow, export, and focus
+remain live. Focus-depth traversal and auto-collapse are not yet implemented in the engine;
+their controls are disabled honestly while in Every-node mode rather than silently doing
+nothing.
+
+The Playwright e2e coverage for graph routing lives in `tests/e2e/ledger.spec.js`; the
+worker/renderer contract is pinned by `tests/test_graph_every_asset.py`, which executes the
+real worker in Node and asserts the renderer's structural invariants.
 
 If the server has more than 20,000 final nodes or more than 200,000 raw relationships, the
-all profile refuses the request with an explicit capacity response. Narrow by repository or entity
-type, or reduce the workspace graph; it never silently samples the all-node projection. Time,
-layer, and relation filters still shape an accepted scene, but are not advertised as ways around
-the raw entity and relationship safety ceilings because those limits are enforced first.
+profile refuses the request with an explicit capacity response. Narrow by repository or entity
+type, or reduce the workspace graph; it never silently samples the projection.