Graph view + Maps of Content

The Atlas index is the graph. There is one entry point: a force-directed graph of every note, with a Maps of Content strip below it. The graph answers “what’s connected to what,” the index notes answer “where do I start,” and together they reach every note — there is no second index to keep in sync.

Open the Atlas. Hover a node to trace its neighborhood, click to open the note, type in the search box to filter by title, drag/scroll to move.

A category is just a note

The old index had a hardcoded skeleton — a closed kind enum (bug/feature/analysis/reference) baked into the schema, fabricated as synthetic graph nodes, and special-cased in a metadata table. That’s one concept smeared across three places, and it was closed. The graph dissolves it: each category is now a real note marked moc: true — Bugs, Features, Analysis, Reference — and a note is filed under one through the single edge mechanism, parents. Nothing is synthetic; nothing is complected:

No enum, no synthetic nodes. An index note is a node like any other — it just renders large (a labeled chip in its accent color) and seeds its own card. Want a fifth category, Terminals or Surfaces? Write a fifth moc note. The set is open.
No orphans, complete by construction. Every note carries its index in parents, so it’s connected — the graph is one piece — and it appears in exactly one index card. The four index cards together name every note, so the whole Atlas is reachable with no JavaScript at all.

High-degree topical notes (electricity, solid-fileview, pty-daemon, …) are emphasized as nodes in the graph (always-on labels), but only the explicit moc notes get cards below it.

It reuses the links the Atlas already has

No special frontmatter for edges. A note’s parents — its index note plus any topical hubs — and its same-directory ./slug.html prose links are the only edges, derived by the very pass that powers the dead-link gate and the “Referenced by” backlinks. A node’s degree sets its size; an index note’s accent (color) tints the notes filed under it; membership spokes (an edge touching an index note) are drawn faint so the topical links stay the legible foreground.

How the page stays a self-contained file

Each Atlas page is a committed, self-contained HTML file that previews in kolu’s Code tab with no dev server, and the build is a pure function of source (the ci::atlas-sync gate rebuilds under a scrambled timezone/locale and fails on any drift). The graph honors both:

Layout is computed at build time with d3-force and baked into a static inline <svg> as rounded coordinates. Nothing lays out at runtime.
Determinism is engineered in: nodes are sorted by id and edges by pair-key before the simulation, positions are seeded by that stable index, a fixed number of ticks runs synchronously, and every coordinate is rounded. d3-force v3 carries no Math.random, so the baked geometry is byte-identical on every rebuild.
The only client JS is one is:inline script for interaction (zoom/pan, hover-highlight, title search, click-to-open) — so no _astro bundle is emitted and the page stays one file. Nodes are real <a> links and the Maps-of-Content cards are plain linked lists, so the page reads and navigates with JS off.

Where this could go

decomplectA category is a real moc note filed via parents (no kind enum, no synthetic nodes); graph + Maps of Content as the single index; title search; build-time d3-force baked to a self-contained SVG.
1Filter/focus by index or maturity; isolate one index’s cluster in place.
2Flag weakly-linked notes (only the index edge) as a “wire these up” nudge.
3Deep-link into the graph centered on the note you came from (a “see this in context” link from each note).

The index, rethought — one graph over the existing link structure, where a category is just a note. The link graph is the source of truth; this is the way to see and walk it.