diff --git a/soleprint/atlas2/docgen/.gitignore b/soleprint/atlas2/docgen/.gitignore
index f58baf9..b055b03 100644
--- a/soleprint/atlas2/docgen/.gitignore
+++ b/soleprint/atlas2/docgen/.gitignore
@@ -3,3 +3,4 @@ out/
 __pycache__/
 *.pyc
 .venv/
+.docgen/
diff --git a/soleprint/atlas2/docgen/Makefile b/soleprint/atlas2/docgen/Makefile
index ac3585d..d963bac 100644
--- a/soleprint/atlas2/docgen/Makefile
+++ b/soleprint/atlas2/docgen/Makefile
@@ -43,6 +43,7 @@ SLUG   ?=
 # en_US.UTF-8 from the environment and --reader rejects it.
 READER ?= python
 OVERLAY ?=
+NOTES  ?=
 CONFIG ?= docgen.toml
 ONLY   ?=
 CHECK  ?=
@@ -54,7 +55,7 @@ SLUG_ARG  := $(if $(SLUG),--slug $(SLUG))
 OVER_ARG  := $(if $(OVERLAY),--overlay $(OVERLAY))
 ONLY_ARGS := $(foreach n,$(subst $(comma), ,$(ONLY)),--only $(n))
 
-.PHONY: help sync lock book run check ir db code view graph index site minimap explore docs self doctor clean
+.PHONY: help sync lock book run scaffold check ir db code view graph index site minimap explore docs self doctor clean
 
 help:  ## List every target
 	@echo "docgen — static analysis of a tree, and the artifacts that fall out of it"
@@ -68,6 +69,7 @@ help:  ## List every target
 	@echo "  BOOK=/path            where a book goes, and which book to check"
 	@echo "  READER=python|code    ast, or tree-sitter    SLUG=name   what to call the book"
 	@echo "  OVERLAY=overlay.json  hand-written notebook additions, re-applied every build"
+	@echo "  NOTES=notes/          markdown filed by page: notes/<book>/<page>.md"
 	@echo "  CONFIG=docgen.toml    a run file             ONLY=a,b    just these books"
 	@echo "  CHECK=1               with run: each book's own level after building it"
 	@echo
@@ -92,11 +94,14 @@ book:  ## SRC (or SCHEMA/OPENAPI/HAR) -> one operation, measured at both ends
 	  $(if $(OPENAPI),--openapi "$(OPENAPI)") \
 	  $(if $(HAR),--har "$(HAR)") \
 	  -o "$(if $(BOOK),$(BOOK),$(OUT)/book)" \
-	  $(STYLE_ARGS) $(SLUG_ARG) $(OVER_ARG)
+	  $(STYLE_ARGS) $(SLUG_ARG) $(OVER_ARG) $(if $(NOTES),--notes "$(NOTES)")
 
-run:  ## CONFIG (a run file) -> every book it lists; ONLY=a,b for some
+run:  ## CONFIG (a run file or a project file) -> every book it lists; ONLY=a,b for some
 	@$(CLI) run "$(CONFIG)" $(ONLY_ARGS) $(if $(CHECK),--check)
 
+scaffold:  ## CONFIG -> an empty note for every page and step, never overwriting
+	@$(CLI) scaffold "$(CONFIG)" $(ONLY_ARGS)
+
 check:  ## Prove docgen (or one book, with BOOK=<dir>)
 	@$(CLI) check $(if $(BOOK),"$(BOOK)")
 
diff --git a/soleprint/atlas2/docgen/README.md b/soleprint/atlas2/docgen/README.md
index c07f87d..b02ddf8 100644
--- a/soleprint/atlas2/docgen/README.md
+++ b/soleprint/atlas2/docgen/README.md
@@ -17,17 +17,25 @@ extractors/        →   graph IR (JSON)   →   emitters/
 make sync                       # optional: .venv with every group, from uv.lock
 make check                      # prove it, on a tree it builds itself
 make book SRC=/path/to/repo     # one whole operation, measured at both ends
-make run CONFIG=docgen.toml     # every book a run file lists
+make run CONFIG=docgen.toml     # every book a run file lists, or a project's document
+make scaffold CONFIG=docgen.toml  # an empty note for every page and step
+python3 -m docgen contract        # the instructions to hand a model
 make help
 ```
 
-The full documentation is `docs/index.html` — open it in a browser.
+The full documentation is `docs/index.html` — open it in a browser. Start with
+**Your first project** for a step-by-step walkthrough.
+
+**For a model** writing `docgen.toml` and notes: `python3 -m docgen contract` prints
+`docs/models.md` — every key, every rule, every error with its fix. Attach it (with
+explode's contract, if replies go through explode). The suite checks it against the
+loaders, so it cannot say something docgen does not accept.
 
 ## Layout
 
 ```
 cli/            the command line — every command, and nothing else
-book/           an operation: larder measure, steps, web output, run files
+book/           an operation: larder measure, steps, pages, notes, documents, run files
 extractors/     source -> IR, one per source type
 ir/             the contract: schema.json, the dataclasses, the validator
 ops/            IR -> a smaller IR
@@ -69,6 +77,40 @@ stops the others; unknown keys are refused; a rebuild replaces the previous
 build's outputs and never touches a hand-written `checks.py`.
 `docgen.example.toml` runs against the shipped fixtures.
 
+## Project files, pages and notes
+
+A **project file** is one document built from several sources — the shape a model
+writes unprompted:
+
+```toml
+[project]
+name = "orders-api"
+
+[extract.openapi]
+spec = "doc/contracts/openapi.yaml"
+
+[extract.code]
+root = "src"
+ext  = [".cs"]
+
+[emit.notebook]
+output = "../docs_out/orders_api_notebook"
+```
+
+Each `[extract.*]` is a book — a *part* of every output — and each `[emit.*]` an
+output made of all of them. Keys docgen deliberately doesn't do (`[extract.db] url`,
+shell/YAML/SQL `ext`, unknown readers) are refused with what to do instead.
+
+A book's diagram is split into **pages** by structure — overview first, one page per
+subsystem — measured until each fits its column. On the site the diagrams are inline,
+so a box opens its page; in a notebook, a page index links every figure, and each
+figure is an SVG cell attachment that renders without running anything.
+
+Hand-written text goes in **notes**: `notes/<book>/<page>.md` lands above that page.
+`make scaffold` writes an empty stub for every spot; a note whose page disappeared is
+reported and fails the check level. `docgen.project.example.toml` builds the fixtures
+into one document with a sample note.
+
 Or as three composable commands, which is what the Makefile is wrapping — run
 from the directory above this one:
 
@@ -240,8 +282,8 @@ about either.
 ## Testing
 
 ```bash
-make check                  # docgen's own suite: 287 after make sync, 272 with nothing
-make check BOOK=out/book/x  # one book's own level — generated and hand-written checks
+make check                  # docgen's own suite: 346 after make sync, 331 with nothing
+make check BOOK=out/book/x  # one book's own level — or a project's .docgen/<name>
 make doctor                 # the machine; never fails
 ```
 
diff --git a/soleprint/atlas2/docgen/book/build.py b/soleprint/atlas2/docgen/book/build.py
index 6df0abd..0122b96 100644
--- a/soleprint/atlas2/docgen/book/build.py
+++ b/soleprint/atlas2/docgen/book/build.py
@@ -73,7 +73,7 @@ EXTRACTORS = {
 TAKES_EXCLUDE = {"python", "code"}
 
 
-def extract(kind: str, source, *, exclude=(), identity=None):
+def extract(kind: str, source, *, exclude=(), identity=None, suffixes=None):
     """(IR dict, Larder) for one source type, dispatched through EXTRACTORS."""
     from importlib import import_module
 
@@ -91,6 +91,8 @@ def extract(kind: str, source, *, exclude=(), identity=None):
     kwargs = {"identity": identity or str(source)}
     if kind in TAKES_EXCLUDE:
         kwargs["exclude"] = exclude
+    if kind == "code" and suffixes:
+        kwargs["suffixes"] = suffixes
     g = fn(source, **kwargs)
 
     ir = g.to_dict()
@@ -102,7 +104,7 @@ def extract(kind: str, source, *, exclude=(), identity=None):
     return ir, Larder.from_dict(measured)
 
 
-def spec_from(book: Book, ir: dict) -> dict:
+def spec_from(book: Book, ir: dict, *, prelude_dir: str | None = None) -> dict:
     """The book's ledger -> a notebook spec, with the two measures at the ends.
 
     Reuses `notebook.spec`'s step vocabulary rather than inventing one, so
@@ -128,7 +130,10 @@ def spec_from(book: Book, ir: dict) -> dict:
             ),
         ),
         spec_mod._step("prelude", "code", title="Reading a step on its own",
-                       code=PRELUDE),
+                       # In its own book directory the notebook reads steps from
+                       # where it is opened; elsewhere it points back at the book.
+                       code=PRELUDE if prelude_dir is None else PRELUDE.replace(
+                           "BOOK = Path.cwd()", f"BOOK = Path.cwd() / {prelude_dir!r}", 1)),
     ]
 
     for s in book.steps:
@@ -191,7 +196,9 @@ def _load_cell(step_id: str, artifact: str) -> str:
     if artifact.endswith(".json"):
         return (
             f'data = load("{artifact}")\n'
-            'if data:\n'
+            'if isinstance(data, list):\n'
+            '    print(f"{len(data)} item(s)")\n'
+            'elif data:\n'
             '    if "nodes" in data:\n'
             '        print(f\'{len(data["nodes"])} nodes, {len(data.get("edges", []))} edges\')\n'
             '    else:\n'
@@ -222,7 +229,20 @@ def _load_cell(step_id: str, artifact: str) -> str:
 # remove first. Named, never globbed: a book directory also holds the hand-written
 # `checks.py` and `overlay.json`, and a misconfigured output path could point at
 # somebody's source tree — so nothing outside this list is ever deleted.
-GENERATED = ("book.json", "notebook.ipynb", "steps", "site", "explore")
+GENERATED = ("book.json", "notebook.ipynb", "steps", "site", "explore", "document.json")
+
+# The steps a book runs, by id — fixed, so a note can be filed under one before
+# the book has ever been built, and a skipped step does not make its note drift.
+STEP_LABELS = (
+    ("ir", "the graph, extracted"),
+    ("view", "the default view for this source"),
+    ("pages", "the diagram, split into pages that fit"),
+    ("graph", "the whole view in one drawing"),
+    ("index", "readable without a diagram"),
+    ("sidebar", "navigation, for whatever renders it"),
+    ("minimap", "what is where, read from the colours"),
+    ("explore", "navigate on one side, explore on the other"),
+)
 
 
 def clear(out) -> list[str]:
@@ -253,12 +273,19 @@ def clear(out) -> list[str]:
     return removed
 
 
-def run(kind: str, source, out, *, slug: str | None = None, style: str = "lucid",
-        theme: str | None = None, exclude=(), overlay=None, quiet: bool = False) -> Book:
-    """The whole book, in one process. Returns it; `book.json` is written."""
+def build_book(kind: str, source, out, *, slug: str | None = None, exclude=(),
+               ops: dict | None = None, suffixes=None, quiet: bool = False) -> Book:
+    """One book's steps: larder, IR, view, pages, drawings. No site, no notebook.
+
+    Those are a document's outputs and are assembled by `book/document.py`, which
+    may put several books into one of each. The book is returned open — its last
+    step is added once the outputs it belongs to exist.
+    """
     from ..ir import check
     from ..ops import classify, overview
+    from ..ops.pages import for_view
     from ..style import Style
+    from .document import apply_ops
 
     out = Path(out)
     slug = slug or Path(str(source)).name or "book"
@@ -270,7 +297,7 @@ def run(kind: str, source, out, *, slug: str | None = None, style: str = "lucid"
         if not quiet:
             print(text)
 
-    ir, larder = extract(kind, source, exclude=exclude)
+    ir, larder = extract(kind, source, exclude=exclude, suffixes=suffixes)
     if larder is None:
         larder = Larder(kind=kind, identity=str(source), unit="document", seen=0)
     book = Book(slug=slug, larder=larder, out=out)
@@ -289,22 +316,31 @@ def run(kind: str, source, out, *, slug: str | None = None, style: str = "lucid"
     p.write_text(json.dumps(ir, indent=2) + "\n")
     book.step("ir", "the graph, extracted", p, note=f"{len(ir['nodes'])} nodes")
 
-    view = overview(ir)
+    view = apply_ops(overview(ir), ops or {})
+    book.view = view
     p = steps_dir / "view.json"
     p.write_text(json.dumps(view, indent=2) + "\n")
     verdict = classify(view)
     book.step("view", "the default view for this source", p,
               note=f"{verdict['kind']} — {verdict['why']}")
 
-    style_obj = Style.load(style, theme=theme)
+    # Which pages exist — width-free, so it is decided once. Each output lays
+    # them out for its own column when it is assembled.
+    book.pages = for_view(ir, view)
+    p = steps_dir / "pages.json"
+    p.write_text(json.dumps(
+        [{k: v for k, v in page.items() if k != "ir"} for page in book.pages],
+        indent=2) + "\n")
+    book.step("pages", "the diagram, split into pages that fit", p,
+              note=f"{len(book.pages)} page(s)")
+
+    style_obj = Style.load("lucid")
 
-    # The drawing, chosen by structure rather than by the caller — the same
-    # `draw()` the `emit auto` and `emit site` commands use, so the three can
-    # never disagree about what a graph wants.
+    # The whole view in one drawing — still worth having as a step on its own,
+    # and the same `draw()` the `emit auto` command uses.
     from ..emitters.auto import draw
 
     drawn = draw(view, style_obj)
-    graph_rel = None
     labels = {"erd": "drawn as an ERD", "dot": f"drawn as a {verdict['kind']}",
               "index": "not a diagram — written as a list"}
     if drawn["content"] is None:
@@ -315,8 +351,6 @@ def run(kind: str, source, out, *, slug: str | None = None, style: str = "lucid"
             p.write_bytes(drawn["content"])
         else:
             p.write_text(drawn["content"])
-        if drawn["suffix"] == ".svg":
-            graph_rel = f"steps/{p.name}"
         book.step("graph", labels[drawn["emitter"]], p, note=drawn["why"])
 
     from ..emitters.index import to_markdown, to_sidebar
@@ -343,38 +377,41 @@ def run(kind: str, source, out, *, slug: str | None = None, style: str = "lucid"
     except Exception as e:  # noqa: BLE001
         book.step("explore", "explorer not built", skipped=f"{type(e).__name__}: {e}")
 
-    # -- the last step ----------------------------------------------------
-    from ..emitters.site import write as site_write
-    site_dir = out / "site"
-    site_write(view, style_obj, site_dir,
-               graph=Path(graph_rel).name if graph_rel else None,
-               title=slug, book=book.to_dict())
-    if graph_rel and (out / graph_rel).exists():
-        (site_dir / Path(graph_rel).name).write_bytes((out / graph_rel).read_bytes())
-
-    # close() BEFORE the notebook spec is built, not after. The spec quotes the
-    # book measure, and the book measure only includes the site once the last
-    # step exists — build it the other way round and the notebook says 7
-    # artifacts while book.json says 8, which is exactly what it did.
-    book.close(site=site_dir)
-
-    from ..emitters.notebook import write as nb_write
-    from ..notebook import spec as spec_mod
-    spec, spec_problems = spec_mod.merge(spec_from(book, ir), overlay)
-    nb_write(spec, out / "notebook.ipynb")
-    # Recorded by name and not by size: a notebook cannot report its own byte
-    # count without changing it.
-    book.notebook = "notebook.ipynb"
+    return book
 
-    for pr in spec_problems:
-        say(f"  overlay  {pr}")
-    path = book.write()
 
+def run(kind: str, source, out, *, slug: str | None = None, style: str = "lucid",
+        theme: str | None = None, exclude=(), overlay=None, notes=None,
+        quiet: bool = False) -> Book:
+    """One book, as a one-book document whose outputs live in its own directory.
+
+    `book.json`, `steps/`, `site/` and `notebook.ipynb` land where they always did;
+    the site and notebook are now assembled the same way a many-book document's are.
+    """
+    from .document import Document, Output, Part, build
+
+    out = Path(out)
+    slug = slug or Path(str(source)).name or "book"
+    doc = Document(
+        name=slug, title=slug, build=out, inline=True,
+        notes=Path(notes) if notes else None,
+        parts=[Part(name=slug, kind=kind, source=Path(source), out=out,
+                    exclude=tuple(exclude), overlay=overlay)],
+        outputs=[Output("site", out / "site", style=style, theme=theme),
+                 Output("notebook", out / "notebook.ipynb", style=style, theme=theme)],
+    )
+    build(doc, quiet=quiet)
+    book = doc.books[0]
+
+    for pr in doc.problems:
+        if not quiet:
+            print(f"  note     {pr}")
     m = book.measure()
-    say(f"  book     {m['nodes']} nodes · {m['edges']} edges · "
-        f"{m['external']} external · {len(m['artifacts'])} artifacts")
-    for r in book.compare():
-        say(f"  {'ok  ' if r['ok'] else 'LOST'}     {r['claim']}")
-    say(f"  open     {site_dir / 'index.html'}")
-    say(f"           {path}")
+    if not quiet:
+        print(f"  book     {m['nodes']} nodes · {m['edges']} edges · "
+              f"{m['external']} external · {len(m['artifacts'])} artifacts")
+        for r in book.compare():
+            print(f"  {'ok  ' if r['ok'] else 'LOST'}     {r['claim']}")
+        print(f"  open     {out / 'site' / 'index.html'}")
+        print(f"           {out / 'book.json'}")
     return book
diff --git a/soleprint/atlas2/docgen/book/checks.py b/soleprint/atlas2/docgen/book/checks.py
index 8c69b78..3c56c5c 100644
--- a/soleprint/atlas2/docgen/book/checks.py
+++ b/soleprint/atlas2/docgen/book/checks.py
@@ -90,8 +90,9 @@ class Loaded:
 class Report:
     """rig's reporting shape: sections, one line per decision, nothing aborts."""
 
-    def __init__(self):
+    def __init__(self, subject: str = "book"):
         self.passed, self.failed, self.skipped = 0, [], 0
+        self.subject = subject
 
     def note(self, text: str) -> None:
         print(f"\n{text}")
@@ -116,7 +117,7 @@ class Report:
         # it summarises — which is how this was found, piping to `tail`.
         sys.stdout.flush()
         if not self.failed:
-            print(f"{self.passed} checks passed — this book still holds"
+            print(f"{self.passed} checks passed — this {self.subject} still holds"
                   + (f", {self.skipped} skipped" if self.skipped else ""))
             return 0
         print(f"FAILED — {len(self.failed)} of {self.passed + len(self.failed)}: "
@@ -204,6 +205,12 @@ def generated(book: Loaded, r: Report) -> None:
             r.check("the page admits the book is incomplete", True,
                     "This book is incomplete" in html)
 
+    # A book built inline — its own site and notebook in its own directory —
+    # also carries the document ledger, and with it the notes it used.
+    doc_ledger = book.dir / "document.json"
+    if doc_ledger.is_file():
+        _notes_drift(json.loads(doc_ledger.read_text()), r)
+
     r.note("the book is reproducible")
     # A timestamp would make two builds of an unchanged larder differ, which
     # destroys the only useful property a ledger has: that a diff means a real
@@ -272,3 +279,99 @@ def _run_cells(cells: list, cwd: Path) -> tuple[int, str | None]:
     finally:
         os.chdir(previous)
     return ran, failure
+
+
+# -- documents --------------------------------------------------------------------
+
+def _notes_drift(ledger: dict, r: Report) -> None:
+    r.note("notes land where they are filed")
+    # A note filed under a page that no longer exists has nowhere to go. It is
+    # reported rather than dropped, because dropping it is how hand-written text
+    # goes stale without anyone noticing — and this is the check that fails on it.
+    drift = (ledger.get("notes") or {}).get("drift") or []
+    r.check("no note is filed under a page or step that is gone", [], drift)
+
+
+def document(build_dir, r: Report) -> None:
+    """A document's own assertions: its books, its notes, every output it wrote."""
+    import re
+
+    build_dir = Path(build_dir)
+    ledger = json.loads((build_dir / "document.json").read_text())
+    books = ledger.get("books") or []
+
+    r.note("the document is made of its books")
+    r.check("it has at least one book", True, len(books) > 0)
+    for b in books:
+        r.check(f"book {b['name']} has its ledger", True, (Path(b["dir"]) / "book.json").is_file())
+
+    _notes_drift(ledger, r)
+
+    total_pages = sum(len(b.get("pages") or []) for b in books)
+    for out in ledger.get("outputs") or []:
+        path = Path(out["path"])
+        if out["emitter"] == "notebook":
+            r.note(f"the notebook — {path.name}")
+            if not path.is_file():
+                r.check(f"{path} exists", True, False)
+                continue
+            nb = json.loads(path.read_text())
+            text = ["".join(c.get("source") or []) for c in nb.get("cells") or []]
+            # Both ends of every part: the rule holds per book, not only overall.
+            # Matched by book name, because the document's own closing cell is
+            # also headed "— what came out" and a bare count mistook it for a part.
+            def heading(name, end):
+                return sum(1 for t in text if f"## {name} — what came {end}" in t)
+
+            r.check("every book part opens with what came in", [],
+                    [b["name"] for b in books if heading(b["name"], "in") != 1])
+            r.check("every book part closes with what came out", [],
+                    [b["name"] for b in books if heading(b["name"], "out") != 1])
+            figures = [c for c in nb.get("cells") or [] if '<a name="page-' in "".join(c.get("source") or [])]
+            r.check("every page is a figure", total_pages, len(figures))
+            drawn = sum(1 for c in figures if (c.get("attachments") or {}))
+            if drawn < len(figures):
+                r.skip("figures carry their SVG", f"{len(figures) - drawn} not drawn — Graphviz absent?")
+            else:
+                r.check("every figure carries its SVG, so it renders without running", True, True)
+        elif out["emitter"] == "site":
+            r.note(f"the site — {path}")
+            index = path / "index.html"
+            r.check("index.html exists", True, index.is_file())
+            if not index.is_file():
+                continue
+            html = index.read_text()
+            # Counted on the ledger's own labels, not the phrase: the page's
+            # introduction says "what came in" too, and was counted as a book.
+            r.check("the index shows what came in, for every book", len(books),
+                    html.count("<dt>what came in</dt>"))
+            r.check("the index shows what came out, for every book", len(books),
+                    html.count("<dt>what came out</dt>"))
+            manifest = path / ".docgen-output.json"
+            written = json.loads(manifest.read_text()).get("written", []) if manifest.is_file() else []
+            r.check("the output lists what it wrote", True, bool(written))
+            r.check("every file it lists is there", [], [w for w in written if not (path / w).is_file()])
+            # Every link on every page resolves — the drill-down is only worth
+            # having if following it never lands on nothing.
+            broken = []
+            for page in sorted(path.glob("*/*.html")):
+                for href in re.findall(r'href="([^"#?]+)', page.read_text()):
+                    if href.startswith(("http:", "https:", "mailto:")):
+                        continue
+                    if not (page.parent / href).exists():
+                        broken.append(f"{page.relative_to(path)} -> {href}")
+            r.check("every link on every page opens something", [], broken[:10])
+            pages = sum(1 for b in books for p in (b.get("pages") or [])
+                        if (path / b["name"] / f"{p['slug']}.html").is_file())
+            r.check("every page has its own HTML", total_pages, pages)
+
+
+def document_failures(build_dir, *, quiet: bool = True) -> list[str]:
+    import contextlib
+    import io
+
+    report = Report("document")
+    sink = io.StringIO() if quiet else None
+    with contextlib.redirect_stdout(sink) if sink else contextlib.nullcontext():
+        document(build_dir, report)
+    return list(report.failed)
diff --git a/soleprint/atlas2/docgen/book/config.py b/soleprint/atlas2/docgen/book/config.py
index e6391a6..bff8674 100644
--- a/soleprint/atlas2/docgen/book/config.py
+++ b/soleprint/atlas2/docgen/book/config.py
@@ -71,8 +71,8 @@ SOURCES = {"root": "python", "schema": "db", "openapi": "openapi", "har": "usage
 READERS = ("python", "code")
 
 TOP_KEYS = {"reference", "defaults", "book"}
-DEFAULT_KEYS = {"out", "style", "theme", "exclude", "reader"}
-BOOK_KEYS = {"name", "out", "style", "theme", "exclude", "reader", "overlay", *SOURCES}
+DEFAULT_KEYS = {"out", "style", "theme", "exclude", "reader", "notes"}
+BOOK_KEYS = {"name", "out", "style", "theme", "exclude", "reader", "overlay", "notes", *SOURCES}
 
 # A book name becomes a directory name and a slug, so it is held to what is safe
 # as both — no separators, nothing that means something to a shell.
@@ -99,6 +99,7 @@ class Entry:
     theme: str | None = None
     overlay: Path | None = None
     exclude: tuple = ()
+    notes: Path | None = None
 
     def line(self) -> str:
         return f"{self.name:<18} {self.kind:<8} {self.source}  ->  {self.out}"
@@ -137,18 +138,38 @@ def _within(inner: Path, outer: Path) -> bool:
     return inner == outer or outer in inner.parents
 
 
-def load(path) -> RunFile:
-    """Read and resolve a run file. Raises ConfigError listing every problem."""
-    path = Path(path)
+def _read(path: Path) -> dict:
     if tomllib is None:
         raise ConfigError(path, ["run files need Python 3.11+ (tomllib)"])
     try:
-        data = tomllib.loads(path.read_text())
+        return tomllib.loads(path.read_text())
     except OSError as e:
         raise ConfigError(path, [f"cannot read: {e}"]) from None
     except tomllib.TOMLDecodeError as e:
         raise ConfigError(path, [f"not valid TOML: {e}"]) from None
 
+
+def load(path):
+    """Read and resolve a run file of either shape. Raises ConfigError listing
+    every problem.
+
+    Returns a `RunFile` for a `[[book]]` list, or a `ProjectFile` for a project.
+    A file with both is refused: which one it meant is exactly what nobody should
+    have to guess.
+    """
+    path = Path(path)
+    data = _read(path)
+    if "project" in data and "book" in data:
+        raise ConfigError(path, [
+            "this file has both [project] and [[book]] — use one shape per file: "
+            "[project] for one document built from several sources, [[book]] for a "
+            "list of independent books"])
+    if "project" in data:
+        return load_project(path, data)
+    return _load_books(path, data)
+
+
+def _load_books(path: Path, data: dict) -> "RunFile":
     base = path.resolve().parent
     problems: list[str] = []
 
@@ -246,10 +267,12 @@ def load(path) -> RunFile:
         if source_key == "root" and source.is_dir() and _within(out, source):
             problems.append(f"{where}: out {out} is inside the tree it reads ({source})")
 
+        notes = _path(pick("notes", "notes"), base)
+
         books.append(Entry(
             name=name, kind=kind, source=source, out=out,
             style=pick("style", "lucid"), theme=pick("theme"),
-            overlay=overlay, exclude=tuple(exclude),
+            overlay=overlay, exclude=tuple(exclude), notes=notes,
         ))
 
     seen_names, seen_outs = {}, {}
@@ -282,13 +305,30 @@ def apply_reference(runfile: RunFile) -> str | None:
     return str(runfile.reference)
 
 
-def run(runfile: RunFile, names=None, *, check: bool = False, quiet: bool = True):
+def _checks(directory, quiet: bool) -> list[str]:
+    import contextlib
+    import io
+
+    from . import checks as checks_mod
+
+    report = checks_mod.Report()
+    loaded = checks_mod.Loaded(directory)
+    sink = io.StringIO() if quiet else None
+    with contextlib.redirect_stdout(sink) if sink else contextlib.nullcontext():
+        checks_mod.generated(loaded, report)
+        checks_mod.custom(loaded, report)
+    return list(report.failed)
+
+
+def run(runfile, names=None, *, check: bool = False, quiet: bool = True):
     """Build every selected book, in order. One failure never stops the rest.
 
-    Returns one result per book:
+    Returns one result per book, plus one per output for a project:
         {"name", "out", "ok", "error", "lost": [claims], "checks_failed": [names]}
     """
-    from . import checks as checks_mod
+    if isinstance(runfile, ProjectFile):
+        return run_project(runfile, names, check=check, quiet=quiet)
+
     from .build import run as build
 
     apply_reference(runfile)
@@ -303,7 +343,7 @@ def run(runfile: RunFile, names=None, *, check: bool = False, quiet: bool = True
                 overlay = spec_mod.load(entry.overlay)
             book = build(entry.kind, entry.source, entry.out, slug=entry.name,
                          style=entry.style, theme=entry.theme, exclude=entry.exclude,
-                         overlay=overlay, quiet=quiet)
+                         overlay=overlay, notes=entry.notes, quiet=quiet)
             result["lost"] = [r["claim"] for r in book.compare() if not r["ok"]]
         except Exception as e:  # noqa: BLE001 - one bad book must not cost the run
             result["error"] = f"{type(e).__name__}: {e}"
@@ -311,17 +351,265 @@ def run(runfile: RunFile, names=None, *, check: bool = False, quiet: bool = True
             continue
 
         if check:
-            import contextlib
-            import io
-
-            report = checks_mod.Report()
-            loaded = checks_mod.Loaded(entry.out)
-            sink = io.StringIO() if quiet else None
-            with contextlib.redirect_stdout(sink) if sink else contextlib.nullcontext():
-                checks_mod.generated(loaded, report)
-                checks_mod.custom(loaded, report)
-            result["checks_failed"] = list(report.failed)
+            result["checks_failed"] = _checks(entry.out, quiet)
 
         result["ok"] = not result["lost"] and not result["checks_failed"]
         results.append(result)
     return results
+
+
+# -- the project shape ----------------------------------------------------------
+#
+# One file per project, the shape a model writes unprompted:
+#
+#     [project]          name, title, notes, build, reference
+#     [extract.<kind>]   one book per table; [[extract.<kind>]] for several
+#     [ops]              applied to every book's view, before paging
+#     [emit.<output>]    notebook, site — each assembles every book
+#
+# It compiles to the same Document a [[book]] entry does, so everything after
+# loading is one code path.
+
+PROJECT_KEYS = {"name", "title", "notes", "build", "reference"}
+PROJECT_TOP = {"project", "extract", "ops", "emit"}
+EXTRACT_KEYS = {
+    "python": {"name", "root", "exclude", "overlay"},
+    "code": {"name", "root", "ext", "exclude", "overlay"},
+    "db": {"name", "schema", "overlay"},
+    "openapi": {"name", "spec", "overlay"},
+    "usage": {"name", "har", "overlay"},
+}
+EXTRACT_SOURCE = {"python": "root", "code": "root", "db": "schema",
+                  "openapi": "spec", "usage": "har"}
+OPS_KEYS = {"drop_stdlib", "drop_builtins", "drop_external", "only", "drop"}
+EMITTERS = {"notebook", "site"}
+EMIT_KEYS = {"output", "style", "theme", "width"}
+
+# Keys a model reaches for that docgen deliberately does not do, with what to do
+# instead. Refused with the reason rather than with a bare "unknown key", because
+# the reason is the useful half of the refusal.
+NOT_SUPPORTED = {
+    ("db", "url"): (
+        "docgen reads a schema dump and never connects to a database — and a URL in "
+        "a committed file is a credential in a committed file. Write the schema with "
+        "`modelgen from-db`, then set `schema = \"path/to/schema.json\"`"
+    ),
+}
+
+
+@dataclass
+class ProjectFile:
+    path: Path
+    document: object                 # book.document.Document
+    reference: Path | None = None
+
+    @property
+    def books(self):
+        return self.document.parts
+
+
+def load_project(path: Path, data: dict) -> ProjectFile:
+    from ..extractors.code import LANGUAGES
+    from .document import Document, Output, Part
+
+    base = path.resolve().parent
+    problems: list[str] = []
+
+    for key in sorted(set(data) - PROJECT_TOP):
+        problems.append(f"unknown top-level key {key!r} — a project file has: "
+                        f"{', '.join(sorted(PROJECT_TOP))}")
+
+    project = data.get("project") or {}
+    for key in sorted(set(project) - PROJECT_KEYS):
+        problems.append(f"[project] has unknown key {key!r} — have: {', '.join(sorted(PROJECT_KEYS))}")
+    name = project.get("name")
+    if not isinstance(name, str) or not NAME.match(name):
+        problems.append("[project] needs a name of letters, digits, '.', '_' or '-'")
+        name = "project"
+    title = project.get("title") or name
+    notes = _path(project.get("notes", "notes"), base)
+    build_root = _path(project.get("build", ".docgen"), base)
+    reference = _path(project["reference"], base) if "reference" in project else None
+    if reference is not None and not reference.is_dir():
+        problems.append(f"[project] reference {reference} is not a directory")
+
+    # -- extract ----------------------------------------------------------------
+    extract = data.get("extract") or {}
+    if not isinstance(extract, dict) or not extract:
+        problems.append("no sources — add at least one [extract.<kind>] table "
+                        f"({', '.join(sorted(EXTRACT_KEYS))})")
+        extract = {}
+    parts, names = [], set()
+    for kind, tables in extract.items():
+        if kind not in EXTRACT_KEYS:
+            problems.append(f"[extract.{kind}]: no reader named {kind!r} — have: "
+                            f"{', '.join(sorted(EXTRACT_KEYS))}")
+            continue
+        tables = tables if isinstance(tables, list) else [tables]
+        for i, raw in enumerate(tables):
+            where = f"[extract.{kind}]" + (f"[{i}]" if len(tables) > 1 else "")
+            if not isinstance(raw, dict):
+                problems.append(f"{where} must be a table")
+                continue
+            for key in sorted(set(raw) - EXTRACT_KEYS[kind]):
+                reason = NOT_SUPPORTED.get((kind, key))
+                problems.append(f"{where} {key}: {reason}" if reason else
+                                f"{where} has unknown key {key!r} — have: "
+                                f"{', '.join(sorted(EXTRACT_KEYS[kind]))}")
+            book = raw.get("name") or (kind if len(tables) == 1 else None)
+            if not isinstance(book, str) or not NAME.match(book):
+                problems.append(f"{where} needs a name when there are several "
+                                f"[[extract.{kind}]] tables")
+                continue
+            if book in names:
+                problems.append(f"{where}: a book named {book!r} already exists — set `name`")
+                continue
+            names.add(book)
+
+            src_key = EXTRACT_SOURCE[kind]
+            if src_key not in raw:
+                problems.append(f"{where} needs `{src_key}`")
+                continue
+            source = _path(raw[src_key], base)
+            if src_key == "root":
+                if not source.is_dir():
+                    problems.append(f"{where}: root {source} is not a directory")
+            elif not source.is_file():
+                problems.append(f"{where}: {src_key} {source} is not a file")
+
+            exclude = raw.get("exclude", [])
+            if not isinstance(exclude, list) or not all(isinstance(x, str) for x in exclude):
+                problems.append(f"{where}: exclude must be a list of directory names")
+                exclude = []
+
+            ext = raw.get("ext")
+            if ext is not None:
+                if not isinstance(ext, list) or not all(isinstance(x, str) for x in ext):
+                    problems.append(f"{where}: ext must be a list like [\".cs\", \".ts\"]")
+                else:
+                    missing = [x for x in ext if x not in LANGUAGES]
+                    if missing:
+                        problems.append(
+                            f"{where}: no grammar for {', '.join(missing)} — code reads "
+                            f"{', '.join(sorted(LANGUAGES))}. Shell, YAML and SQL have no "
+                            "reader yet; leave them out rather than expect them in the book")
+
+            overlay = None
+            if "overlay" in raw:
+                overlay_path = _path(raw["overlay"], base)
+                if not overlay_path.is_file():
+                    problems.append(f"{where}: overlay {overlay_path} is not a file")
+                else:
+                    import json
+                    overlay = json.loads(overlay_path.read_text())
+
+            out = build_root / name / "books" / book
+            if src_key == "root" and source.is_dir() and _within(out, source):
+                problems.append(f"{where}: build directory {out} is inside the tree it reads "
+                                f"({source}) — set [project] build outside it")
+            parts.append(Part(name=book, kind=kind, source=source, out=out,
+                              exclude=tuple(exclude), overlay=overlay,
+                              suffixes=tuple(ext) if ext else None))
+
+    # -- ops --------------------------------------------------------------------
+    ops = data.get("ops") or {}
+    for key in sorted(set(ops) - OPS_KEYS):
+        problems.append(f"[ops] has unknown key {key!r} — have: {', '.join(sorted(OPS_KEYS))}")
+    for key in ("only", "drop"):
+        if key in ops and not (isinstance(ops[key], list)
+                               and all(isinstance(x, str) for x in ops[key])):
+            problems.append(f"[ops] {key} must be a list of kinds")
+    for part in parts:
+        part.ops = {k: v for k, v in ops.items() if k in OPS_KEYS}
+
+    # -- emit -------------------------------------------------------------------
+    emit = data.get("emit") or {}
+    outputs = []
+    if not emit:
+        problems.append("no outputs — add [emit.notebook] or [emit.site] with an `output`")
+    for emitter, raw in emit.items():
+        where = f"[emit.{emitter}]"
+        if emitter not in EMITTERS:
+            problems.append(f"{where}: no output named {emitter!r} — have: "
+                            f"{', '.join(sorted(EMITTERS))}")
+            continue
+        if not isinstance(raw, dict):
+            problems.append(f"{where} must be a table")
+            continue
+        for key in sorted(set(raw) - EMIT_KEYS):
+            problems.append(f"{where} has unknown key {key!r} — have: {', '.join(sorted(EMIT_KEYS))}")
+        if "output" not in raw:
+            problems.append(f"{where} needs `output`")
+            continue
+        width = raw.get("width")
+        if width is not None and (not isinstance(width, int) or width < 200):
+            problems.append(f"{where}: width must be a number of pixels, 200 or more")
+            width = None
+        target = _path(raw["output"], base)
+        for part in parts:
+            if part.kind in ("python", "code") and part.source.is_dir() \
+                    and _within(target, part.source):
+                problems.append(f"{where}: output {target} is inside the tree book "
+                                f"{part.name!r} reads — the next run would read it")
+        outputs.append(Output(emitter=emitter, path=target, style=raw.get("style", "lucid"),
+                              theme=raw.get("theme"), width=width))
+
+    if problems:
+        raise ConfigError(path, problems)
+    doc = Document(name=name, title=title, build=build_root / name, parts=parts,
+                   outputs=outputs, notes=notes)
+    return ProjectFile(path=path, document=doc, reference=reference)
+
+
+def select_parts(project: ProjectFile, names) -> list:
+    if not names:
+        return list(project.document.parts)
+    known = {p.name for p in project.document.parts}
+    unknown = [n for n in names if n not in known]
+    if unknown:
+        raise ConfigError(project.path, [
+            f"no book named {n!r} — have: {', '.join(sorted(known))}" for n in unknown])
+    return [p for p in project.document.parts if p.name in set(names)]
+
+
+def run_project(project: ProjectFile, names=None, *, check: bool = False, quiet: bool = True):
+    """Build a project's document: every book, then every output.
+
+    `--only` narrows the books that go into this build's outputs, which is useful
+    while writing notes for one of them — the outputs are then that subset, and
+    say so in their ledger.
+    """
+    from dataclasses import replace
+
+    from .document import build
+
+    apply_reference(project)
+    doc = replace(project.document, parts=select_parts(project, names), books=[], problems=[])
+    results = []
+    try:
+        build(doc, quiet=quiet)
+    except Exception as e:  # noqa: BLE001 - reported, not raised
+        return [{"name": doc.name, "out": str(doc.build), "ok": False,
+                 "error": f"{type(e).__name__}: {e}", "lost": [], "checks_failed": []}]
+
+    for part in doc.parts:
+        if part.name in doc.failed:
+            results.append({"name": part.name, "out": str(part.out), "ok": False,
+                            "error": doc.failed[part.name], "lost": [], "checks_failed": []})
+    for book in doc.books:
+        lost = [r["claim"] for r in book.compare() if not r["ok"]]
+        failed = _checks(book.out, quiet) if check else []
+        results.append({"name": book.slug, "out": str(book.out), "ok": not lost and not failed,
+                        "error": None, "lost": lost, "checks_failed": failed})
+    if check and doc.books:
+        from . import checks as checks_mod
+        failed = checks_mod.document_failures(doc.build, quiet=quiet)
+    else:
+        failed = []
+    # A failed book is already its own row; the document row carries what else
+    # went wrong — notes that drifted, an overlay that no longer matches.
+    rest = [p for p in doc.problems if not p.startswith("book ") or "was not built" not in p]
+    results.append({"name": f"{doc.name} (document)", "out": str(doc.build),
+                    "ok": not rest and not failed and bool(doc.books), "error": None,
+                    "lost": rest, "checks_failed": failed})
+    return results
diff --git a/soleprint/atlas2/docgen/book/document.py b/soleprint/atlas2/docgen/book/document.py
new file mode 100644
index 0000000..4de04b5
--- /dev/null
+++ b/soleprint/atlas2/docgen/book/document.py
@@ -0,0 +1,448 @@
+"""
+A document: several books, assembled into each output.
+
+    Document
+    ├── books      one per source — each keeps its own larder → steps → book
+    ├── notes      hand-written markdown, filed by page (book/notes.py)
+    └── outputs    a notebook, a site, … — each one made of every book, as parts
+
+A book is a templated part of the final output, not the output itself. A project
+with an OpenAPI contract and a C# tree is one document of two books: one notebook
+and one site, each with a part per book. A `[[book]]` run file is the same thing
+with one book per document, which is what it always was.
+
+## Built once, rendered per output
+
+Extraction, the view and the page structure happen once per book. Rendering
+does not, because what a page looks like depends on where it is going: a site
+column is narrower than a notebook cell, a site's boxes are links and a
+notebook's cannot be, and each output can have its own theme. So each output
+lays the pages out for its own width and draws them itself.
+
+## Both ends, at both levels
+
+Every book part still opens with what came in and closes with what came out. A
+document of several books also opens with every larder and closes with every
+reconciliation, so the rule — any operation is measured at both ends — holds for
+the whole as well as for each part.
+"""
+
+import json
+import os
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from . import Book
+from .notes import Notes, data_uri, images
+from .larder import Larder
+
+MANIFEST = ".docgen-output.json"
+
+
+@dataclass
+class Output:
+    emitter: str                     # "notebook" | "site"
+    path: Path
+    style: str = "lucid"
+    theme: str | None = None
+    width: int | None = None         # px; each emitter has its own default
+
+
+@dataclass
+class Part:
+    """One book to build: a source, and where its artifacts go."""
+
+    name: str
+    kind: str
+    source: Path
+    out: Path
+    exclude: tuple = ()
+    overlay: dict | None = None
+    ops: dict = field(default_factory=dict)
+    suffixes: tuple | None = None    # code only: which extensions to read
+
+
+@dataclass
+class Document:
+    name: str
+    title: str
+    build: Path                      # where document.json goes
+    parts: list[Part]
+    outputs: list[Output]
+    notes: Path | None = None
+    inline: bool = False             # a single [[book]]: outputs live inside its directory
+    books: list[Book] = field(default_factory=list)
+    problems: list[str] = field(default_factory=list)
+    failed: dict = field(default_factory=dict)     # book name -> why it was not built
+
+
+# -- views --------------------------------------------------------------------
+
+OPS = ("drop_stdlib", "drop_builtins", "drop_external", "only", "drop")
+
+
+def apply_ops(view: dict, ops: dict) -> dict:
+    """A project's `[ops]`, on top of the default view. Unknown keys never get here."""
+    from ..ops import filter as F
+
+    if ops.get("drop_stdlib"):
+        view = F.drop_stdlib(view)
+    if ops.get("drop_builtins"):
+        view = F.drop_builtins(view)
+    if ops.get("drop_external"):
+        view = F.drop_external(view)
+    if ops.get("drop"):
+        view = F.drop_kinds(view, ops["drop"])
+    if ops.get("only"):
+        view = F.only_kinds(view, ops["only"])
+    return view
+
+
+# -- output bookkeeping -------------------------------------------------------
+
+def clear_output(directory: Path) -> list[str]:
+    """Remove exactly what the last build wrote into an output directory.
+
+    A page that disappeared between builds would otherwise linger — still on disk,
+    still linked from nowhere, still found by search. The manifest lists every file
+    written; anything not in it, including a hand-written file someone dropped in,
+    is left alone.
+    """
+    manifest = directory / MANIFEST
+    if not manifest.is_file():
+        return []
+    try:
+        written = json.loads(manifest.read_text()).get("written", [])
+    except (OSError, json.JSONDecodeError):
+        return []
+    removed = []
+    for rel in written:
+        target = (directory / rel)
+        if target.is_file() and directory in target.resolve().parents:
+            target.unlink()
+            removed.append(rel)
+    # Directories docgen made and has now emptied — never one with anything left.
+    for d in sorted({(directory / r).parent for r in written}, key=lambda p: -len(p.parts)):
+        if d != directory and d.is_dir() and not any(d.iterdir()):
+            d.rmdir()
+    manifest.unlink()
+    return removed
+
+
+def write_manifest(directory: Path, paths: list[Path]) -> None:
+    rel = sorted({p.relative_to(directory).as_posix() for p in paths if p.is_file()})
+    (directory / MANIFEST).write_text(json.dumps({"written": rel}, indent=2) + "\n")
+
+
+# -- pages, rendered ----------------------------------------------------------
+
+def rendered_pages(book: Book, style, width: int, *, url=None):
+    """[(page, svg or None)] laid out for `width`. `url(page)` makes boxes links."""
+    from ..emitters.paged import fits_for, links_for, render
+    from ..ops.pages import layout
+
+    fits, measured = fits_for(style, width)
+    laid = layout(book.pages, fits)
+    known = {n["id"] for n in book.ir["nodes"]}
+    out = []
+    for page in laid:
+        links = None
+        if url is not None:
+            links = links_for(laid, page, url)
+            # A box with no page of its own opens its section of the reference
+            # page, where its docstring and file are — when it is a real node.
+            for n in page["ir"]["nodes"]:
+                if n["id"] not in links and n["id"] in known \
+                        and not (n.get("attrs") or {}).get("context"):
+                    links[n["id"]] = f"reference.html#{n['id']}"
+        page["measured"] = measured
+        out.append((page, render(page, style, width, links=links)))
+    return out
+
+
+def caption(page: dict) -> str:
+    nodes = page["ir"]["nodes"]
+    parts = [f"{len(nodes)} box{'es' if len(nodes) != 1 else ''}",
+             f"{len(page['ir']['edges'])} relationship{'s' if len(page['ir']['edges']) != 1 else ''}"]
+    context = sum(1 for n in nodes if (n.get("attrs") or {}).get("context"))
+    if context:
+        parts.append(f"{context} outside this subsystem")
+    if page.get("children"):
+        parts.append(f"opens into {len(page['children'])} page{'s' if len(page['children']) != 1 else ''}")
+    if (page.get("options") or {}).get("rankdir") == "LR":
+        parts.append("drawn left to right to fit the width")
+    if page.get("too_wide"):
+        parts.append("still wider than the page — this level has no smaller structure to split into")
+    return " · ".join(parts)
+
+
+# -- the notebook ---------------------------------------------------------------
+
+def _note_step(text: str, base: Path) -> tuple[str, dict]:
+    """A note for a notebook cell: local images become cell attachments."""
+    attachments = {}
+    for ref, name, mime, data in images(text, base):
+        import base64
+        text = text.replace(f"]({ref})", f"](attachment:{name})")
+        attachments[name] = {mime: base64.b64encode(data).decode("ascii")}
+    return text, attachments
+
+
+def _with_note(step: dict, notes: Notes, book: str | None, spot: str) -> dict:
+    text = notes.book(book, spot) if book else notes.document(spot)
+    if text is None:
+        return step
+    path = notes.path(book, spot)
+    text, attachments = _note_step(text, path.parent)
+    step = dict(step)
+    step["before"] = text + ("\n\n" + step["before"] if step.get("before") else "")
+    if attachments:
+        step["before_attachments"] = {**(step.get("before_attachments") or {}), **attachments}
+    return step
+
+
+def notebook_spec(doc: Document, notes: Notes, output: Output, notebook_dir: Path) -> dict:
+    """Every book's part, in order, with the document's own ends when there are several."""
+    from ..emitters.paged import NOTEBOOK_WIDTH
+    from ..notebook import spec as spec_mod
+    from ..ops.pages import slugify
+    from ..style import Style
+    from .build import spec_from
+
+    style = Style.load(output.style, theme=output.theme)
+    width = output.width or NOTEBOOK_WIDTH
+    several = len(doc.books) > 1
+    steps: list[dict] = []
+
+    missing = ""
+    if doc.failed:
+        missing = ("\n\n**This document is incomplete** — these books could not be built "
+                   "and are not below:\n\n"
+                   + "\n".join(f"- `{n}` — {why}" for n, why in sorted(doc.failed.items())))
+    if several or doc.failed:
+        lines = "\n".join(f"- **{b.slug}** — {b.larder.line()}" for b in doc.books)
+        steps.append(spec_mod._step(
+            "document", "md", title=doc.title,
+            text=(f"Built from {len(doc.books)} book(s). Each part below opens with what "
+                  f"came in and closes with what came out.\n\n{lines}{missing}")))
+
+    for i, book in enumerate(doc.books):
+        rel = os.path.relpath(book.out, notebook_dir)
+        base = spec_from(book, book.ir, prelude_dir=None if doc.inline else rel)
+        base_steps = base["steps"]
+
+        figures = []
+        index_lines = []
+        for page, svg in rendered_pages(book, style, width):
+            anchor = f"page-{slugify(book.slug)}-{page['slug']}"
+            index_lines.append(f"{'  ' * page['depth']}- [{page['title']}](#{anchor})"
+                               + (" — *too wide*" if page.get("too_wide") else ""))
+            figures.append(spec_mod._step(
+                f"page-{page['slug']}", "figure", title=page["title"], anchor=anchor,
+                depth=page["depth"], svg=svg, name=f"{page['slug']}.svg",
+                caption=caption(page),
+                why="Graphviz is not installed" if svg is None else None))
+        index = spec_mod._step("pages", "md", title=f"{book.slug} — pages",
+                               text="Each page is one subsystem, drawn small enough to "
+                                    "read. Follow a link to jump to it.\n\n"
+                                    + "\n".join(index_lines))
+
+        ordered = []
+        for step in base_steps:
+            if step["id"] == "book":
+                ordered.extend(figures)
+            ordered.append(step)
+            if step["id"] == "larder":
+                ordered.append(index)
+
+        spec, problems = spec_mod.merge({"meta": {}, "steps": ordered},
+                                        doc.parts_built[i].overlay)
+        doc.problems += [f"{book.slug}: overlay: {p}" for p in problems]
+
+        # Notes are applied after the overlay, so an overlay that moves a step moves
+        # its note with it. A page's note is filed under the page's slug; every
+        # other step under its own id. `_with_note` prepends, so applying the book's
+        # `_intro` last puts it above the larder's own note.
+        part = []
+        for n, step in enumerate(spec["steps"]):
+            sid = step["id"]
+            spot = sid[len("page-"):] if step.get("kind") == "figure" else slugify(sid)
+            step = _with_note(step, notes, book.slug, spot)
+            if n == 0:
+                step = _with_note(step, notes, book.slug, "_intro")
+            if several:
+                step = dict(step, id=f"{book.slug}/{sid}")
+            part.append(step)
+        steps.extend(part)
+
+    if several:
+        lines = []
+        for b in doc.books:
+            m = b.measure()
+            lines.append(f"- **{b.slug}** — {m['nodes']} nodes · {m['edges']} edges · "
+                         f"{m['external']} external")
+            lines += [f"  - {'✓' if r['ok'] else '✗'} {r['claim']}" for r in b.compare()]
+        steps.append(spec_mod._step("document-end", "md", title=f"{doc.title} — what came out",
+                                    text="\n".join(lines)))
+    if steps:
+        steps[0] = _with_note(steps[0], notes, None, "_intro")
+        end = notes.document("_end")
+        if end is not None:
+            text, att = _note_step(end, notes.path(None, "_end").parent)
+            steps.append(spec_mod._step("_end", "md", text=text,
+                                        **({"before_attachments": att} if att else {})))
+    return {"version": spec_mod.SPEC_VERSION, "steps": steps}
+
+
+# -- building -----------------------------------------------------------------
+
+def build(doc: Document, *, quiet: bool = True) -> Document:
+    """Build every book, then every output. Returns the document, ledgers written."""
+    from ..emitters.notebook import write as nb_write
+    from ..ops.pages import slugify
+    from ..style import Style
+    from .build import build_book
+
+    def say(text):
+        if not quiet:
+            print(text)
+
+    notes = Notes(doc.notes)
+    doc.books, doc.failed = [], {}
+    built_parts = []
+    for part in doc.parts:
+        # One book that cannot be built must not cost the others — the same rule a
+        # run of independent books follows. The outputs are assembled from what
+        # was built, and the ledger names what was not and why, so a partial
+        # document is visibly partial rather than quietly short.
+        try:
+            book = build_book(part.kind, part.source, part.out, slug=part.name,
+                              exclude=part.exclude, ops=part.ops, suffixes=part.suffixes,
+                              quiet=quiet)
+        except Exception as e:  # noqa: BLE001 - recorded, not raised
+            reason = f"{type(e).__name__}: {str(e).splitlines()[0] if str(e) else ''}"
+            doc.failed[part.name] = reason
+            doc.problems.append(f"book {part.name!r} was not built — {reason}")
+            say(f"  FAIL     {part.name}: {reason}")
+            continue
+        doc.books.append(book)
+        built_parts.append(part)
+    doc.parts_built = built_parts
+
+    # Sites first: in a single inline book the site is its last step's artifact,
+    # and the notebook quotes the book measure — which only counts the site once
+    # the last step exists.
+    sites = [o for o in doc.outputs if o.emitter == "site"]
+    notebooks = [o for o in doc.outputs if o.emitter == "notebook"]
+    written_outputs = []
+
+    for output in sites:
+        from ..emitters import docsite
+
+        site_dir = Path(output.path)
+        clear_output(site_dir)
+        style = Style.load(output.style, theme=output.theme)
+        width = output.width or docsite.CONTENT_WIDTH
+        books = []
+        for book in doc.books:
+            pages = rendered_pages(book, style, width, url=lambda p: f"{p['slug']}.html")
+            page_notes = {}
+            for page, _ in pages:
+                text = notes.book(book.slug, page["slug"])
+                if text is not None:
+                    base = notes.path(book.slug, page["slug"]).parent
+                    page_notes[page["slug"]] = (text, {ref: data_uri(mime, data)
+                                                       for ref, _, mime, data in images(text, base)})
+            intro = notes.book(book.slug, "_intro")
+            books.append({"book": book, "pages": pages, "notes": page_notes,
+                          "intro": (intro, {}) if intro else None})
+        doc_intro = notes.document("_intro")
+        doc_end = notes.document("_end")
+        files = docsite.write(site_dir, style, title=doc.title, books=books,
+                              intro=doc_intro, end=doc_end, failed=doc.failed)
+        write_manifest(site_dir, files)
+        written_outputs.append({"emitter": "site", "path": str(site_dir), "width": width,
+                                "files": len(files)})
+        say(f"  site     {site_dir / 'index.html'}")
+
+    for book in doc.books:
+        inside = [o for o in sites if doc.inline and Path(o.path).parent == book.out]
+        book.close(site=Path(inside[0].path) if inside else None)
+
+    for output in notebooks:
+        path = Path(output.path)
+        if path.suffix != ".ipynb":
+            clear_output(path)
+            path.mkdir(parents=True, exist_ok=True)
+            target = path / f"{slugify(doc.name)}.ipynb"
+        else:
+            path.parent.mkdir(parents=True, exist_ok=True)
+            target = path
+        spec = notebook_spec(doc, notes, output, target.parent)
+        nb_write(spec, target)
+        if path.suffix != ".ipynb":
+            write_manifest(path, [target])
+        if doc.inline and len(doc.books) == 1:
+            doc.books[0].notebook = os.path.relpath(target, doc.books[0].out)
+        written_outputs.append({"emitter": "notebook", "path": str(target),
+                                "width": output.width or 960})
+        say(f"  notebook {target}")
+
+    known = {b.slug: known_spots(b) for b in doc.books}
+    drift = notes.drift(known)
+    doc.problems += drift
+
+    for book in doc.books:
+        book.write()
+
+    ledger = {
+        "name": doc.name,
+        "title": doc.title,
+        "failed": doc.failed,
+        "books": [{"name": b.slug, "dir": str(b.out),
+                   "pages": [{"id": p["id"], "slug": p["slug"], "parent": p["parent"]}
+                             for p in b.pages]}
+                  for b in doc.books],
+        "outputs": written_outputs,
+        "notes": {"root": str(doc.notes) if doc.notes else None,
+                  "used": sorted(str(p.relative_to(doc.notes)) for p in notes.used) if doc.notes else [],
+                  "drift": drift},
+        "problems": doc.problems,
+    }
+    doc.build.mkdir(parents=True, exist_ok=True)
+    (doc.build / "document.json").write_text(json.dumps(ledger, indent=2) + "\n")
+    return doc
+
+
+def _spots(ir: dict, pages: list[dict]) -> list[tuple[str, str]]:
+    """[(spot id, what it is)] for one book, in reading order."""
+    from ..notebook import spec as spec_mod
+    from ..ops.pages import slugify
+    from .build import STEP_LABELS
+
+    out = [("larder", "what came in"), ("pages", "the page index")]
+    out += [(p["slug"], f"page {p['title']}") for p in pages]
+    out += [(f"step-{sid}", f"step: {label}") for sid, label in STEP_LABELS]
+    # An API-shaped book also carries the endpoint walkthrough; each call is a
+    # spot of its own, under the slug of its id.
+    if any(n["kind"] in ("endpoint", "operation") for n in ir.get("nodes") or []):
+        out += [(slugify(s["id"]), f"{s['kind']}: {s.get('title', s['id'])}")
+                for s in spec_mod.from_ir(ir)["steps"] if s["id"] != "intro"]
+    out.append(("book", "what came out"))
+    return out
+
+
+def known_spots(book: Book) -> set[str]:
+    """Every id a note for this book may be filed under."""
+    return {spot for spot, _ in _spots(book.ir, book.pages)}
+
+
+def plan_spots(part: Part) -> list[tuple[str, str]]:
+    """The spots a book will have, without building it — extraction and pages only."""
+    from ..ops import overview
+    from ..ops.pages import for_view
+    from .build import extract
+
+    ir, _ = extract(part.kind, part.source, exclude=part.exclude, suffixes=part.suffixes)
+    view = apply_ops(overview(ir), part.ops)
+    return _spots(ir, for_view(ir, view))
diff --git a/soleprint/atlas2/docgen/book/notes.py b/soleprint/atlas2/docgen/book/notes.py
new file mode 100644
index 0000000..b509d3c
--- /dev/null
+++ b/soleprint/atlas2/docgen/book/notes.py
@@ -0,0 +1,161 @@
+"""
+Notes: hand-written markdown, filed by the page or step it belongs above.
+
+    notes/
+    ├── _intro.md                   top of the document
+    ├── _end.md                     bottom of the document
+    └── <book>/
+        ├── _intro.md               top of that book's part
+        ├── larder.md               above the "what came in" step
+        ├── overview.md             above the overview page
+        └── docgen.book.md          above the page for `docgen.book`
+
+## Why files named by id
+
+Generation alone gives a document that is never stale and never says anything a
+parser could not work out. Prose is the part only a person can add, and it has
+to survive every rebuild — so it cannot live in the output. An overlay could
+carry it, but as JSON strings with `\\n` escapes, addressed by ids you have to
+guess. A folder of markdown files, one per spot, is something a person or a
+model writes without reading a schema: to put text above a page, create the
+file named after it.
+
+`python3 -m docgen scaffold` writes an empty stub for every spot that has none,
+so the ids are listed rather than guessed. A stub is a single HTML comment, and a
+note that is nothing but that comment renders nothing — so scaffolding a
+hundred spots changes the output not at all until one is filled in.
+
+## Drift is reported, never dropped
+
+When a page is renamed or removed its note has nowhere to go. It is not quietly
+discarded — that is how hand-written text goes stale without anyone noticing —
+it is reported, and the book's own check level fails on it. The same rule the
+notebook overlay follows.
+"""
+
+import base64
+import mimetypes
+import re
+from pathlib import Path
+
+DOCUMENT_SPOTS = ("_intro", "_end")
+BOOK_SPOTS = ("_intro",)
+STUB = re.compile(r"\A\s*<!--\s*docgen note:.*?-->\s*", re.S)
+IMAGE = re.compile(r"!\[([^\]]*)\]\(([^)\s]+)\)")
+
+
+def body(text: str | None) -> str | None:
+    """A note's content, without its stub comment. None when nothing is left."""
+    if text is None:
+        return None
+    text = STUB.sub("", text, count=1).strip()
+    return text or None
+
+
+def stub(where: str) -> str:
+    return (f"<!-- docgen note: {where}. Write markdown below; this comment does "
+            f"not render, and an empty note adds nothing. -->\n")
+
+
+class Notes:
+    """The notes folder of one document. A missing folder is simply no notes."""
+
+    def __init__(self, root):
+        self.root = Path(root) if root else None
+        self.used: set[Path] = set()
+
+    def _read(self, path: Path) -> str | None:
+        if self.root is None or not path.is_file():
+            return None
+        text = body(path.read_text())
+        if text is not None:
+            self.used.add(path)
+        return text
+
+    def document(self, spot: str) -> str | None:
+        return self._read(self.root / f"{spot}.md") if self.root else None
+
+    def book(self, book: str, spot: str) -> str | None:
+        return self._read(self.root / book / f"{spot}.md") if self.root else None
+
+    def path(self, book: str | None, spot: str) -> Path | None:
+        if self.root is None:
+            return None
+        return (self.root / book / f"{spot}.md") if book else (self.root / f"{spot}.md")
+
+    def drift(self, known: dict[str, set[str]]) -> list[str]:
+        """Notes filed under a spot that no longer exists, as readable problems.
+
+        `known` is {book name: every page slug and step id it has}.
+        """
+        if self.root is None or not self.root.is_dir():
+            return []
+        problems = []
+        for path in sorted(self.root.rglob("*.md")):
+            rel = path.relative_to(self.root)
+            if len(rel.parts) == 1:
+                if rel.stem not in DOCUMENT_SPOTS:
+                    problems.append(f"note {rel} is not a document spot "
+                                    f"({', '.join(s + '.md' for s in DOCUMENT_SPOTS)})")
+                continue
+            book = rel.parts[0]
+            if book not in known:
+                problems.append(f"note {rel} is filed under book {book!r}, which this "
+                                f"document does not have — have: {', '.join(sorted(known))}")
+                continue
+            spot = Path(*rel.parts[1:]).with_suffix("").as_posix()
+            if spot not in known[book] and spot not in BOOK_SPOTS:
+                if body(path.read_text()) is None:
+                    continue    # an empty stub for a vanished page says nothing
+                problems.append(f"note {rel} belongs above {spot!r}, which book "
+                                f"{book!r} no longer has — rename or remove it")
+        return problems
+
+    def scaffold(self, spots: dict[str, list[tuple[str, str]]]) -> list[Path]:
+        """Write a stub for every spot without a note. Never overwrites.
+
+        `spots` is {book name: [(spot id, what it is)]}. Returns the files written.
+        """
+        if self.root is None:
+            return []
+        written = []
+        for spot in DOCUMENT_SPOTS:
+            path = self.root / f"{spot}.md"
+            where = "top of the document" if spot == "_intro" else "end of the document"
+            if not path.exists():
+                path.parent.mkdir(parents=True, exist_ok=True)
+                path.write_text(stub(where))
+                written.append(path)
+        for book, entries in spots.items():
+            for spot, where in [("_intro", f"top of book {book}")] + list(entries):
+                path = self.root / book / f"{spot}.md"
+                if path.exists():
+                    continue
+                path.parent.mkdir(parents=True, exist_ok=True)
+                path.write_text(stub(f"{book} › {where}"))
+                written.append(path)
+        return written
+
+
+def images(text: str, base: Path) -> list[tuple[str, str, str, bytes]]:
+    """Local images a note links to: [(markdown ref, name, mime type, bytes)].
+
+    Resolved against the note's own folder. Remote and missing images are left as
+    written — a link that does not resolve here is the author's to see, not ours
+    to delete.
+    """
+    out = []
+    for m in IMAGE.finditer(text):
+        ref = m.group(2)
+        if re.match(r"^[a-z]+:", ref):
+            continue
+        path = (base / ref).resolve()
+        if not path.is_file():
+            continue
+        mime = mimetypes.guess_type(path.name)[0] or "application/octet-stream"
+        out.append((ref, path.name, mime, path.read_bytes()))
+    return out
+
+
+def data_uri(mime: str, data: bytes) -> str:
+    return f"data:{mime};base64,{base64.b64encode(data).decode('ascii')}"
diff --git a/soleprint/atlas2/docgen/cli/__init__.py b/soleprint/atlas2/docgen/cli/__init__.py
index 44f1a18..e7188ec 100644
--- a/soleprint/atlas2/docgen/cli/__init__.py
+++ b/soleprint/atlas2/docgen/cli/__init__.py
@@ -6,6 +6,8 @@ The command line — every command docgen has, and nothing else.
     book       one operation, measured at both ends
     run        every book a run file lists
     check      docgen's own suite, or one book's own level
+    scaffold   empty notes for every page and step, never overwriting
+    contract   the instructions to hand a model that writes docgen.toml
     extract    source -> ir.json
     validate   check an ir.json at the boundary
     view       ir.json -> a narrower ir.json
@@ -36,6 +38,8 @@ COMMANDS = {
     "book": ("book", "one operation, measured at both ends"),
     "run": ("run", "every book a run file lists"),
     "check": ("check", "docgen's own suite, or one book's own level"),
+    "scaffold": ("scaffold", "empty notes for every page and step, never overwriting"),
+    "contract": ("contract", "the instructions to hand a model that writes docgen.toml"),
     "extract": ("extract", "source -> ir.json"),
     "validate": ("validate", "check an ir.json at the boundary"),
     "view": ("view", "ir.json -> a narrower ir.json"),
diff --git a/soleprint/atlas2/docgen/cli/book.py b/soleprint/atlas2/docgen/cli/book.py
index d78ca21..f1db3af 100644
--- a/soleprint/atlas2/docgen/cli/book.py
+++ b/soleprint/atlas2/docgen/cli/book.py
@@ -37,6 +37,9 @@ def main(argv) -> int:
                    help="A hand-written notebook overlay, re-applied on every build.")
     p.add_argument("--exclude", action="append", default=[],
                    help="Directory name to skip. Repeatable.")
+    p.add_argument("--notes", type=Path,
+                   help="A notes folder: <slug>/<page>.md lands above that page. "
+                        "See `scaffold`.")
     p.add_argument("--quiet", "-q", action="store_true")
     args = p.parse_args(argv)
 
@@ -66,7 +69,7 @@ def main(argv) -> int:
     try:
         book = run(kind, source, args.output, slug=args.slug, style=args.style,
                    theme=args.theme, exclude=tuple(args.exclude), overlay=overlay,
-                   quiet=args.quiet)
+                   notes=args.notes, quiet=args.quiet)
     except Exception as e:  # noqa: BLE001 - the CLI reports, it does not traceback
         raise Abort(f"{type(e).__name__}: {e}") from None
 
diff --git a/soleprint/atlas2/docgen/cli/check.py b/soleprint/atlas2/docgen/cli/check.py
index cdd981b..606adda 100644
--- a/soleprint/atlas2/docgen/cli/check.py
+++ b/soleprint/atlas2/docgen/cli/check.py
@@ -34,7 +34,14 @@ def main(argv) -> int:
         # what a fresh one would do.
         return subprocess.call([sys.executable, str(HERE / "selftest.py")])
 
-    from ..book.checks import Loaded, Report, custom, generated
+    from ..book.checks import Loaded, Report, custom, document, generated
+
+    if not (args.book / "book.json").is_file() and (args.book / "document.json").is_file():
+        # A project's build directory: the document's own level.
+        print(f"{args.book}  —  document")
+        r = Report("document")
+        document(args.book, r)
+        return r.total()
 
     try:
         book = Loaded(args.book)
diff --git a/soleprint/atlas2/docgen/cli/contract.py b/soleprint/atlas2/docgen/cli/contract.py
new file mode 100644
index 0000000..2205c4a
--- /dev/null
+++ b/soleprint/atlas2/docgen/cli/contract.py
@@ -0,0 +1,33 @@
+"""
+    python3 -m docgen contract > docgen-contract.md
+
+Print the instructions to hand to a model that writes `docgen.toml` and notes —
+`docs/models.md`, verbatim.
+
+One copy of the wording, printed rather than remembered, the same arrangement as
+`explode.sh --contract`: what a model is asked to write and what docgen accepts
+cannot drift apart, because `selftest.py` checks the file against the loaders —
+every key named, every example loading. Attach it; do not paste it into a
+message body, where markdown gets a say first.
+
+With `explode`, attach both: explode's contract says how to format the reply,
+this one says what goes in the files.
+"""
+
+import argparse
+import sys
+from pathlib import Path
+
+from .common import PROG, Abort
+
+CONTRACT = Path(__file__).resolve().parent.parent / "docs" / "models.md"
+
+
+def main(argv) -> int:
+    p = argparse.ArgumentParser(prog=f"{PROG} contract",
+                                description="Print the instructions for a model.")
+    p.parse_args(argv)
+    if not CONTRACT.is_file():
+        raise Abort(f"{CONTRACT} is missing — is the docgen folder intact?")
+    sys.stdout.write(CONTRACT.read_text())
+    return 0
diff --git a/soleprint/atlas2/docgen/cli/run.py b/soleprint/atlas2/docgen/cli/run.py
index 5c9775b..e0321f5 100644
--- a/soleprint/atlas2/docgen/cli/run.py
+++ b/soleprint/atlas2/docgen/cli/run.py
@@ -30,13 +30,17 @@ def main(argv) -> int:
                    help="Show each book's own output, not just the summary.")
     args = p.parse_args(argv)
 
-    from ..book.config import ConfigError, load, run
+    from ..book.config import ConfigError, ProjectFile, load, run, select_parts
 
     if not args.config.exists():
-        raise Abort(f"no run file at {args.config} — see docgen.example.toml")
+        raise Abort(f"no run file at {args.config} — see docgen.example.toml "
+                    "or docgen.project.example.toml")
     try:
         runfile = load(args.config)
-        selected = runfile.select(args.only)
+        if isinstance(runfile, ProjectFile):
+            selected = select_parts(runfile, args.only)
+        else:
+            selected = runfile.select(args.only)
     except ConfigError as e:
         raise Abort(str(e)) from None
 
@@ -46,13 +50,26 @@ def main(argv) -> int:
         print(f"{runfile.path}  —  {len(selected)} of {len(runfile.books)} book(s)")
         if runfile.reference:
             print(f"  reference  {runfile.reference}")
-        for b in selected:
-            print(f"  {b.line()}")
+        if isinstance(runfile, ProjectFile):
+            doc = runfile.document
+            print(f"  project    {doc.name} — {doc.title}")
+            print(f"  build      {doc.build}")
+            print(f"  notes      {doc.notes}")
+            for part in selected:
+                print(f"  book       {part.name:<16} {part.kind:<8} {part.source}")
+            for o in doc.outputs:
+                print(f"  output     {o.emitter:<16} {o.path}"
+                      + (f"  (width {o.width}px)" if o.width else ""))
+        else:
+            for b in selected:
+                print(f"  {b.line()}")
         return 0
 
     print(f"{runfile.path}  —  {len(selected)} book(s)")
     results = run(runfile, [b.name for b in selected], check=args.check,
                   quiet=not args.verbose)
+    if not results:
+        raise Abort("nothing was built")
 
     width = max(len(r["name"]) for r in results)
     for r in results:
@@ -70,10 +87,12 @@ def main(argv) -> int:
         print(f"  {status}  {r['name']:<{width}}  {detail}")
 
     failed = [r for r in results if not r["ok"]]
+    documents = sum(1 for r in results if r["name"].endswith("(document)"))
+    what = f"{len(results) - documents} book(s)" + (f" in {documents} document" if documents else "")
     print()
     if failed:
-        print(f"{len(failed)} of {len(results)} book(s) did not hold"
+        print(f"{len(failed)} of {len(results)} did not hold ({what})"
               + ("" if args.verbose else " — --verbose for each book's own output"))
         return 1
-    print(f"{len(results)} book(s) built" + (" and checked" if args.check else ""))
+    print(f"{what} built" + (" and checked" if args.check else ""))
     return 0
diff --git a/soleprint/atlas2/docgen/cli/scaffold.py b/soleprint/atlas2/docgen/cli/scaffold.py
new file mode 100644
index 0000000..2dfee75
--- /dev/null
+++ b/soleprint/atlas2/docgen/cli/scaffold.py
@@ -0,0 +1,87 @@
+"""
+    python3 -m docgen scaffold <docgen.toml> [--only NAME ...]
+    python3 -m docgen scaffold <docgen.toml> --list      # print the spots, write nothing
+
+Write an empty note for every spot a document has — the document's top and end,
+each book's top, what came in, the page index, every page, every step, every
+API call, what came out — so the ids are listed rather than guessed.
+
+Never overwrites: a spot that already has a note is left alone, so running it
+again after the sources change only adds the spots that are new. A stub is a
+single HTML comment and renders nothing until somebody writes below it.
+
+Extraction and page structure only — nothing is drawn and no output is written.
+"""
+
+import argparse
+from pathlib import Path
+
+from .common import PROG, Abort
+
+
+def main(argv) -> int:
+    p = argparse.ArgumentParser(prog=f"{PROG} scaffold")
+    p.add_argument("config", type=Path, nargs="?", default=Path("docgen.toml"))
+    p.add_argument("--only", action="append", default=[], metavar="NAME",
+                   help="Just these books. Repeatable.")
+    p.add_argument("--list", action="store_true",
+                   help="Print every spot a note can be filed under, and write nothing — "
+                        "the list to hand a model instead of letting it guess page ids.")
+    args = p.parse_args(argv)
+
+    from ..book.config import ConfigError, ProjectFile, apply_reference, load, select_parts
+    from ..book.document import Part, plan_spots
+    from ..book.notes import Notes
+
+    if not args.config.exists():
+        raise Abort(f"no run file at {args.config}")
+    try:
+        loaded = load(args.config)
+        apply_reference(loaded)
+        if isinstance(loaded, ProjectFile):
+            groups = {loaded.document.notes: select_parts(loaded, args.only)}
+        else:
+            groups = {}
+            for e in loaded.select(args.only):
+                part = Part(name=e.name, kind=e.kind, source=e.source, out=e.out,
+                            exclude=e.exclude)
+                groups.setdefault(e.notes, []).append(part)
+    except ConfigError as e:
+        raise Abort(str(e)) from None
+
+    total = 0
+    for root, parts in groups.items():
+        spots = {}
+        for part in parts:
+            try:
+                spots[part.name] = plan_spots(part)
+            except Exception as e:  # noqa: BLE001 - one bad source must not cost the rest
+                print(f"  skip   {part.name}: {type(e).__name__}: {str(e).splitlines()[0]}")
+        if args.list:
+            # Relative to the run file's folder, which is how a note's path is
+            # written in a reply — not as an absolute path on this machine.
+            base = args.config.resolve().parent
+            try:
+                shown = root.relative_to(base)
+            except ValueError:
+                shown = root
+            rows = [(f"{shown}/_intro.md", "top of the document"),
+                    (f"{shown}/_end.md", "end of the document")]
+            for book, entries in spots.items():
+                rows.append((f"{shown}/{book}/_intro.md", f"top of book {book}"))
+                for spot, where in entries:
+                    has = " (has a note)" if Notes(root).book(book, spot) else ""
+                    rows.append((f"{shown}/{book}/{spot}.md", where + has))
+            width = max(len(r[0]) for r in rows)
+            for path, where in rows:
+                print(f"{path:<{width}}  {where}")
+            continue
+        written = Notes(root).scaffold(spots)
+        total += len(written)
+        existing = sum(len(v) for v in spots.values()) + 2 + len(spots) - len(written)
+        print(f"  notes  {root}  —  {len(written)} new stub(s), {existing} already there")
+        for path in written[:12]:
+            print(f"         {path.relative_to(root)}")
+        if len(written) > 12:
+            print(f"         … and {len(written) - 12} more")
+    return 0
diff --git a/soleprint/atlas2/docgen/docgen.project.example.toml b/soleprint/atlas2/docgen/docgen.project.example.toml
new file mode 100644
index 0000000..fa574f9
--- /dev/null
+++ b/soleprint/atlas2/docgen/docgen.project.example.toml
@@ -0,0 +1,53 @@
+# A project file: one document built from several sources.
+#
+#     make run CONFIG=docgen.project.example.toml CHECK=1
+#     make scaffold CONFIG=docgen.project.example.toml   # a stub note for every spot
+#     python3 -m docgen run docgen.project.example.toml --list
+#
+# Every [extract.*] table is a book — a part of each output. Every [emit.*] table
+# is an output made of all of them. Paths are relative to THIS FILE. Unknown keys
+# are refused with a reason, never ignored.
+#
+# The other shape, a list of independent books, is docgen.example.toml.
+
+[project]
+name  = "docgen-fixtures"
+title = "docgen's own fixtures"
+notes = "fixtures/notes"     # notes/<book>/<page>.md lands above that page
+build = ".docgen"            # book artifacts; gitignore it
+# reference = "../../"       # the repo holding station/tools/modelgen, for OpenAPI
+
+# A tree of Python. Several trees: [[extract.python]] with a `name` each.
+[extract.python]
+name = "extractors"
+root = "extractors"
+
+# A database schema, as `modelgen from-db` writes it. docgen reads the dump and
+# never connects: `url = ...` is refused, since a URL in a committed file is a
+# credential in a committed file.
+[extract.db]
+name   = "schema"
+schema = "fixtures/shop.json"
+
+# An OpenAPI document. Needs pyyaml and the reference repo's modelgen; without
+# them this book fails with a one-line reason and the others still build.
+[extract.openapi]
+name = "api"
+spec = "fixtures/orders.yaml"
+
+# Also available:
+#   [extract.code]    root = "src", ext = [".cs", ".ts"]    (tree-sitter)
+#   [extract.usage]   har = "session.har"
+
+[ops]
+drop_stdlib   = true
+drop_builtins = true
+
+[emit.notebook]
+output = "out/project/notebook"   # a directory: <name>.ipynb goes inside
+theme  = "lucid"
+width  = 960                      # px — pages are split until each fits
+
+[emit.site]
+output = "out/project/site"
+theme  = "dark"
diff --git a/soleprint/atlas2/docgen/docs/img/architecture.svg b/soleprint/atlas2/docgen/docs/img/architecture.svg
index 9df61e1..001a373 100644
--- a/soleprint/atlas2/docgen/docs/img/architecture.svg
+++ b/soleprint/atlas2/docgen/docs/img/architecture.svg
@@ -4,72 +4,72 @@
 <!-- Generated by graphviz version 14.1.2 (0)
  -->
 <!-- Title: ir Pages: 1 -->
-<svg width="2429pt" height="549pt"
- viewBox="0.00 0.00 2429.00 549.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
-<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(21.6 527.6)">
+<svg width="3717pt" height="577pt"
+ viewBox="0.00 0.00 3717.00 577.00" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">
+<g id="graph0" class="graph" transform="scale(1 1) rotate(0) translate(21.6 555.52)">
 <title>ir</title>
-<polygon fill="#0a0a0a" stroke="none" points="-21.6,21.6 -21.6,-527.6 2407.78,-527.6 2407.78,21.6 -21.6,21.6"/>
+<polygon fill="#0a0a0a" stroke="none" points="-21.6,21.6 -21.6,-555.52 3694.95,-555.52 3694.95,21.6 -21.6,21.6"/>
 <g id="docgen" class="cluster module">
 <title>cluster_docgen</title>
-<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="11.06,-8 11.06,-498 2028.06,-498 2028.06,-8 11.06,-8"/>
-<text xml:space="preserve" text-anchor="middle" x="45.31" y="-481.65" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">docgen</text>
+<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="8,-8 8,-498 3332,-498 3332,-8 8,-8"/>
+<text xml:space="preserve" text-anchor="middle" x="42.25" y="-481.65" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">docgen</text>
 </g>
 <g id="docgen.book" class="cluster module">
 <title>cluster_docgen_book</title>
-<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="584.06,-100.5 584.06,-348.5 774.06,-348.5 774.06,-100.5 584.06,-100.5"/>
-<text xml:space="preserve" text-anchor="middle" x="610.06" y="-332.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">book</text>
+<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="1007,-95 1007,-465.5 1213,-465.5 1213,-95 1007,-95"/>
+<text xml:space="preserve" text-anchor="middle" x="1033" y="-449.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">book</text>
 </g>
 <g id="docgen.cli" class="cluster module">
 <title>cluster_docgen_cli</title>
-<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="782.06,-272 782.06,-465.5 1458.06,-465.5 1458.06,-272 782.06,-272"/>
-<text xml:space="preserve" text-anchor="middle" x="798.31" y="-449.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">cli</text>
+<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="2071,-272 2071,-465.5 2976,-465.5 2976,-272 2071,-272"/>
+<text xml:space="preserve" text-anchor="middle" x="2087.25" y="-449.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">cli</text>
 </g>
 <g id="docgen.emitters" class="cluster module">
 <title>cluster_docgen_emitters</title>
-<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="181.06,-16 181.06,-177 576.06,-177 576.06,-16 181.06,-16"/>
-<text xml:space="preserve" text-anchor="middle" x="220.19" y="-160.65" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">emitters</text>
+<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="236,-16 236,-264 741,-264 741,-16 236,-16"/>
+<text xml:space="preserve" text-anchor="middle" x="275.12" y="-247.65" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">emitters</text>
 </g>
 <g id="docgen.extractors" class="cluster module">
 <title>cluster_docgen_extractors</title>
-<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="1466.06,-185 1466.06,-381 1952.06,-381 1952.06,-185 1466.06,-185"/>
-<text xml:space="preserve" text-anchor="middle" x="1511.94" y="-364.65" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">extractors</text>
+<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="1569,-179.5 1569,-381 2063,-381 2063,-179.5 1569,-179.5"/>
+<text xml:space="preserve" text-anchor="middle" x="1614.88" y="-364.65" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">extractors</text>
 </g>
 <g id="docgen.extractors.python" class="cluster module">
 <title>cluster_docgen_extractors_python</title>
-<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="1566.06,-193 1566.06,-348.5 1656.06,-348.5 1656.06,-193 1566.06,-193"/>
-<text xml:space="preserve" text-anchor="middle" x="1599.19" y="-332.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">python</text>
+<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="1577,-187.5 1577,-348.5 1679,-348.5 1679,-187.5 1577,-187.5"/>
+<text xml:space="preserve" text-anchor="middle" x="1610.12" y="-332.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">python</text>
 </g>
 <g id="docgen.ir" class="cluster module">
 <title>cluster_docgen_ir</title>
-<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="1675.06,-16 1675.06,-177 1771.06,-177 1771.06,-16 1675.06,-16"/>
-<text xml:space="preserve" text-anchor="middle" x="1688.69" y="-160.65" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">ir</text>
+<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="1770,-16 1770,-171.5 1866,-171.5 1866,-16 1770,-16"/>
+<text xml:space="preserve" text-anchor="middle" x="1783.62" y="-155.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">ir</text>
 </g>
 <g id="docgen.lab" class="cluster module">
 <title>cluster_docgen_lab</title>
-<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="1532.06,-389 1532.06,-465.5 1632.06,-465.5 1632.06,-389 1532.06,-389"/>
-<text xml:space="preserve" text-anchor="middle" x="1551.31" y="-449.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">lab</text>
+<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="2996,-389 2996,-465.5 3096,-465.5 3096,-389 2996,-389"/>
+<text xml:space="preserve" text-anchor="middle" x="3015.25" y="-449.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">lab</text>
 </g>
 <g id="docgen.notebook" class="cluster module">
 <title>cluster_docgen_notebook</title>
-<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="44.06,-100.5 44.06,-177 129.06,-177 129.06,-100.5 44.06,-100.5"/>
-<text xml:space="preserve" text-anchor="middle" x="86.56" y="-160.65" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">notebook</text>
+<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="793,-95 793,-171.5 878,-171.5 878,-95 793,-95"/>
+<text xml:space="preserve" text-anchor="middle" x="835.5" y="-155.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">notebook</text>
 </g>
 <g id="docgen.ops" class="cluster module">
 <title>cluster_docgen_ops</title>
-<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="746.06,-16 746.06,-92.5 820.06,-92.5 820.06,-16 746.06,-16"/>
-<text xml:space="preserve" text-anchor="middle" x="766.81" y="-76.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">ops</text>
+<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="892,-16 892,-171.5 974,-171.5 974,-16 892,-16"/>
+<text xml:space="preserve" text-anchor="middle" x="912.75" y="-155.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">ops</text>
 </g>
 <g id="docgen.style" class="cluster module">
 <title>cluster_docgen_style</title>
-<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="1209.06,-16 1209.06,-177 1299.06,-177 1299.06,-16 1209.06,-16"/>
-<text xml:space="preserve" text-anchor="middle" x="1234.69" y="-160.65" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">style</text>
+<polygon fill="#1a1a1a" stroke="#333333" stroke-dasharray="5,2" points="1419,-16 1419,-171.5 1509,-171.5 1509,-16 1419,-16"/>
+<text xml:space="preserve" text-anchor="middle" x="1444.62" y="-155.15" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="13.00" fill="#a3a3a3">style</text>
 </g>
 <!-- docgen.__main__ -->
 <g id="docgen.__main__" class="node module">
 <title>docgen.__main__</title>
 <g id="a_docgen.__main__"><a xlink:href="__main__.py" xlink:title="python3 &#45;m docgen &lt;command&gt; [args] &#160;&#160;— see cli/__init__.py for the commands.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1014.96,-237C1014.96,-237 959.16,-237 959.16,-237 953.16,-237 947.16,-231 947.16,-225 947.16,-225 947.16,-213 947.16,-213 947.16,-207 953.16,-201 959.16,-201 959.16,-201 1014.96,-201 1014.96,-201 1020.96,-201 1026.96,-207 1026.96,-213 1026.96,-213 1026.96,-225 1026.96,-225 1026.96,-231 1020.96,-237 1014.96,-237"/>
-<text xml:space="preserve" text-anchor="middle" x="987.06" y="-215.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">__main__</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1326.9,-316C1326.9,-316 1271.1,-316 1271.1,-316 1265.1,-316 1259.1,-310 1259.1,-304 1259.1,-304 1259.1,-292 1259.1,-292 1259.1,-286 1265.1,-280 1271.1,-280 1271.1,-280 1326.9,-280 1326.9,-280 1332.9,-280 1338.9,-286 1338.9,-292 1338.9,-292 1338.9,-304 1338.9,-304 1338.9,-310 1332.9,-316 1326.9,-316"/>
+<text xml:space="preserve" text-anchor="middle" x="1299" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">__main__</text>
 </a>
 </g>
 </g>
@@ -77,776 +77,1004 @@
 <g id="docgen.cli.book" class="node module">
 <title>docgen.cli.book</title>
 <g id="a_docgen.cli.book"><a xlink:href="cli/book.py" xlink:title="python3 &#45;m docgen book &#45;&#45;root SRC &#45;o out/book/name [&#45;&#45;reader python|code]">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1018.46,-433C1018.46,-433 983.66,-433 983.66,-433 977.66,-433 971.66,-427 971.66,-421 971.66,-421 971.66,-409 971.66,-409 971.66,-403 977.66,-397 983.66,-397 983.66,-397 1018.46,-397 1018.46,-397 1024.46,-397 1030.46,-403 1030.46,-409 1030.46,-409 1030.46,-421 1030.46,-421 1030.46,-427 1024.46,-433 1018.46,-433"/>
-<text xml:space="preserve" text-anchor="middle" x="1001.06" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">book</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M2218.4,-433C2218.4,-433 2183.6,-433 2183.6,-433 2177.6,-433 2171.6,-427 2171.6,-421 2171.6,-421 2171.6,-409 2171.6,-409 2171.6,-403 2177.6,-397 2183.6,-397 2183.6,-397 2218.4,-397 2218.4,-397 2224.4,-397 2230.4,-403 2230.4,-409 2230.4,-409 2230.4,-421 2230.4,-421 2230.4,-427 2224.4,-433 2218.4,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="2201" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">book</text>
 </a>
 </g>
 </g>
 <!-- docgen.__main__&#45;&gt;docgen.cli.book -->
 <g id="edge1" class="edge imports">
 <title>docgen.__main__&#45;&gt;docgen.cli.book</title>
-<path fill="none" stroke="#4a4a4a" d="M988.32,-237.46C988.85,-244.82 989.52,-254.12 990.28,-264.58"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="988.18,-264.66 990.71,-270.49 992.37,-264.36 988.18,-264.66"/>
+<path fill="none" stroke="#4a4a4a" d="M1307.25,-316.31C1317.77,-336.12 1338,-367.54 1366,-381 1381.73,-388.56 1860.35,-385.77 2063.59,-387.03"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2063.47,-389.13 2069.49,-387.07 2063.5,-384.93 2063.47,-389.13"/>
 </g>
 <!-- docgen.book.build -->
 <g id="docgen.book.build" class="node module">
 <title>docgen.book.build</title>
 <g id="a_docgen.book.build"><a xlink:href="book/build.py" xlink:title="Run a book: larder, the steps, the web output, the book measure.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M651.46,-237C651.46,-237 616.66,-237 616.66,-237 610.66,-237 604.66,-231 604.66,-225 604.66,-225 604.66,-213 604.66,-213 604.66,-207 610.66,-201 616.66,-201 616.66,-201 651.46,-201 651.46,-201 657.46,-201 663.46,-207 663.46,-213 663.46,-213 663.46,-225 663.46,-225 663.46,-231 657.46,-237 651.46,-237"/>
-<text xml:space="preserve" text-anchor="middle" x="634.06" y="-215.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">build</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1078.4,-316C1078.4,-316 1043.6,-316 1043.6,-316 1037.6,-316 1031.6,-310 1031.6,-304 1031.6,-304 1031.6,-292 1031.6,-292 1031.6,-286 1037.6,-280 1043.6,-280 1043.6,-280 1078.4,-280 1078.4,-280 1084.4,-280 1090.4,-286 1090.4,-292 1090.4,-292 1090.4,-304 1090.4,-304 1090.4,-310 1084.4,-316 1078.4,-316"/>
+<text xml:space="preserve" text-anchor="middle" x="1061" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">build</text>
 </a>
 </g>
 </g>
+<!-- docgen.book.document -->
+<g id="docgen.book.document" class="node module">
+<title>docgen.book.document</title>
+<g id="a_docgen.book.document"><a xlink:href="book/document.py" xlink:title="A document: several books, assembled into each output.">
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1092.78,-231.5C1092.78,-231.5 1027.22,-231.5 1027.22,-231.5 1021.23,-231.5 1015.23,-225.5 1015.23,-219.5 1015.23,-219.5 1015.23,-207.5 1015.23,-207.5 1015.23,-201.5 1021.23,-195.5 1027.22,-195.5 1027.22,-195.5 1092.78,-195.5 1092.78,-195.5 1098.78,-195.5 1104.78,-201.5 1104.78,-207.5 1104.78,-207.5 1104.78,-219.5 1104.78,-219.5 1104.78,-225.5 1098.78,-231.5 1092.78,-231.5"/>
+<text xml:space="preserve" text-anchor="middle" x="1060" y="-209.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">document</text>
+</a>
+</g>
+</g>
+<!-- docgen.book.build&#45;&gt;docgen.book.document -->
+<g id="edge3" class="edge imports">
+<title>docgen.book.build&#45;&gt;docgen.book.document</title>
+<path fill="none" stroke="#4a4a4a" d="M1038.24,-279.5C1033.08,-267.69 1032.11,-251.94 1035.41,-238.89"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1037.33,-239.76 1037.21,-233.41 1033.34,-238.46 1037.33,-239.76"/>
+</g>
 <!-- docgen.book.larder -->
 <g id="docgen.book.larder" class="node module">
 <title>docgen.book.larder</title>
 <g id="a_docgen.book.larder"><a xlink:href="book/larder.py" xlink:title="What went in — the first step of every book.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M733.84,-144.5C733.84,-144.5 692.29,-144.5 692.29,-144.5 686.29,-144.5 680.29,-138.5 680.29,-132.5 680.29,-132.5 680.29,-120.5 680.29,-120.5 680.29,-114.5 686.29,-108.5 692.29,-108.5 692.29,-108.5 733.84,-108.5 733.84,-108.5 739.84,-108.5 745.84,-114.5 745.84,-120.5 745.84,-120.5 745.84,-132.5 745.84,-132.5 745.84,-138.5 739.84,-144.5 733.84,-144.5"/>
-<text xml:space="preserve" text-anchor="middle" x="713.06" y="-122.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">larder</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1192.78,-139C1192.78,-139 1151.22,-139 1151.22,-139 1145.22,-139 1139.22,-133 1139.22,-127 1139.22,-127 1139.22,-115 1139.22,-115 1139.22,-109 1145.22,-103 1151.22,-103 1151.22,-103 1192.78,-103 1192.78,-103 1198.78,-103 1204.78,-109 1204.78,-115 1204.78,-115 1204.78,-127 1204.78,-127 1204.78,-133 1198.78,-139 1192.78,-139"/>
+<text xml:space="preserve" text-anchor="middle" x="1172" y="-117.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">larder</text>
 </a>
 </g>
 </g>
 <!-- docgen.book.build&#45;&gt;docgen.book.larder -->
 <g id="edge2" class="edge imports">
 <title>docgen.book.build&#45;&gt;docgen.book.larder</title>
-<path fill="none" stroke="#4a4a4a" d="M638.38,-200.55C647.85,-186.15 665.46,-165.62 681.58,-149.99"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="682.95,-151.58 685.87,-145.94 680.07,-148.53 682.95,-151.58"/>
+<path fill="none" stroke="#4a4a4a" d="M1086.43,-279.56C1093.12,-275.28 1099.77,-270.12 1105,-264 1134.33,-229.67 1146.4,-176.83 1156.71,-146.22"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1158.63,-147.09 1158.65,-140.73 1154.67,-145.68 1158.63,-147.09"/>
 </g>
 <!-- docgen.book.build&#45;&gt;docgen.book.larder -->
-<g id="edge3" class="edge imports">
+<g id="edge4" class="edge imports">
 <title>docgen.book.build&#45;&gt;docgen.book.larder</title>
-<path fill="none" stroke="#4a4a4a" d="M660.21,-200.55C675.61,-186.4 693.48,-166.34 704.69,-150.81"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="706.24,-152.27 707.92,-146.14 702.78,-149.88 706.24,-152.27"/>
+<path fill="none" stroke="#4a4a4a" d="M1090.61,-292.35C1108.58,-287.44 1128.72,-278.37 1141,-264 1170.2,-229.82 1182.29,-177.28 1181.58,-146.61"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1183.69,-146.67 1181.22,-140.82 1179.5,-146.94 1183.69,-146.67"/>
 </g>
 <!-- docgen.emitters.auto -->
 <g id="docgen.emitters.auto" class="node module">
 <title>docgen.emitters.auto</title>
 <g id="a_docgen.emitters.auto"><a xlink:href="emitters/auto.py" xlink:title="Draw it the way its structure asks to be drawn.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M344.34,-144.5C344.34,-144.5 311.79,-144.5 311.79,-144.5 305.79,-144.5 299.79,-138.5 299.79,-132.5 299.79,-132.5 299.79,-120.5 299.79,-120.5 299.79,-114.5 305.79,-108.5 311.79,-108.5 311.79,-108.5 344.34,-108.5 344.34,-108.5 350.34,-108.5 356.34,-114.5 356.34,-120.5 356.34,-120.5 356.34,-132.5 356.34,-132.5 356.34,-138.5 350.34,-144.5 344.34,-144.5"/>
-<text xml:space="preserve" text-anchor="middle" x="328.06" y="-122.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">auto</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M619.27,-139C619.27,-139 586.73,-139 586.73,-139 580.73,-139 574.73,-133 574.73,-127 574.73,-127 574.73,-115 574.73,-115 574.73,-109 580.73,-103 586.73,-103 586.73,-103 619.27,-103 619.27,-103 625.27,-103 631.27,-109 631.27,-115 631.27,-115 631.27,-127 631.27,-127 631.27,-133 625.27,-139 619.27,-139"/>
+<text xml:space="preserve" text-anchor="middle" x="603" y="-117.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">auto</text>
 </a>
 </g>
 </g>
 <!-- docgen.book.build&#45;&gt;docgen.emitters.auto -->
-<g id="edge4" class="edge imports">
+<g id="edge5" class="edge imports">
 <title>docgen.book.build&#45;&gt;docgen.emitters.auto</title>
-<path fill="none" stroke="#4a4a4a" d="M604.5,-205.54C585.58,-198.17 560.3,-189.43 537.06,-185 501.44,-178.2 406.94,-192.3 374.06,-177 361.61,-171.21 350.93,-160.37 343.01,-150.3"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="344.85,-149.26 339.57,-145.72 341.49,-151.78 344.85,-149.26"/>
+<path fill="none" stroke="#4a4a4a" d="M1031.23,-295.13C992.77,-291.98 924.2,-283.9 869,-264 798.11,-238.45 793.64,-202.88 722,-179.5 690.97,-169.37 678.16,-186.15 649,-171.5 636.91,-165.42 626.37,-154.77 618.45,-144.9"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="620.33,-143.91 615.01,-140.42 617,-146.46 620.33,-143.91"/>
 </g>
 <!-- docgen.emitters.explore -->
 <g id="docgen.emitters.explore" class="node module">
 <title>docgen.emitters.explore</title>
 <g id="a_docgen.emitters.explore"><a xlink:href="emitters/explore.py" xlink:title="Two panes: a minimap to navigate by, and a detail pane to explore with.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M251.34,-144.5C251.34,-144.5 200.79,-144.5 200.79,-144.5 194.79,-144.5 188.79,-138.5 188.79,-132.5 188.79,-132.5 188.79,-120.5 188.79,-120.5 188.79,-114.5 194.79,-108.5 200.79,-108.5 200.79,-108.5 251.34,-108.5 251.34,-108.5 257.34,-108.5 263.34,-114.5 263.34,-120.5 263.34,-120.5 263.34,-132.5 263.34,-132.5 263.34,-138.5 257.34,-144.5 251.34,-144.5"/>
-<text xml:space="preserve" text-anchor="middle" x="226.06" y="-122.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">explore</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M526.27,-139C526.27,-139 475.73,-139 475.73,-139 469.73,-139 463.73,-133 463.73,-127 463.73,-127 463.73,-115 463.73,-115 463.73,-109 469.73,-103 475.73,-103 475.73,-103 526.27,-103 526.27,-103 532.27,-103 538.27,-109 538.27,-115 538.27,-115 538.27,-127 538.27,-127 538.27,-133 532.27,-139 526.27,-139"/>
+<text xml:space="preserve" text-anchor="middle" x="501" y="-117.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">explore</text>
 </a>
 </g>
 </g>
 <!-- docgen.book.build&#45;&gt;docgen.emitters.explore -->
-<g id="edge5" class="edge imports">
+<g id="edge6" class="edge imports">
 <title>docgen.book.build&#45;&gt;docgen.emitters.explore</title>
-<path fill="none" stroke="#4a4a4a" d="M604.52,-205.39C585.61,-197.97 560.34,-189.23 537.06,-185 509.17,-179.93 308.41,-187.45 282.06,-177 267.68,-171.3 254.55,-160.17 244.62,-149.91"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="246.39,-148.72 240.77,-145.76 243.32,-151.59 246.39,-148.72"/>
+<path fill="none" stroke="#4a4a4a" d="M1031.31,-295.92C952.41,-292.79 741.83,-282.76 717,-264 684.83,-239.69 716.56,-203.28 684,-179.5 661.16,-162.82 583.12,-182.34 557,-171.5 543.05,-165.71 530.2,-154.95 520.34,-144.93"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="521.87,-143.49 516.22,-140.58 518.82,-146.38 521.87,-143.49"/>
 </g>
 <!-- docgen.emitters.index -->
 <g id="docgen.emitters.index" class="node module">
 <title>docgen.emitters.index</title>
 <g id="a_docgen.emitters.index"><a xlink:href="emitters/index.py" xlink:title="IR &#45;&gt; an index. Markdown for reading, JSON for a sidebar.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M545.96,-60C545.96,-60 508.16,-60 508.16,-60 502.16,-60 496.16,-54 496.16,-48 496.16,-48 496.16,-36 496.16,-36 496.16,-30 502.16,-24 508.16,-24 508.16,-24 545.96,-24 545.96,-24 551.96,-24 557.96,-30 557.96,-36 557.96,-36 557.96,-48 557.96,-48 557.96,-54 551.96,-60 545.96,-60"/>
-<text xml:space="preserve" text-anchor="middle" x="527.06" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">index</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M415.9,-60C415.9,-60 378.1,-60 378.1,-60 372.1,-60 366.1,-54 366.1,-48 366.1,-48 366.1,-36 366.1,-36 366.1,-30 372.1,-24 378.1,-24 378.1,-24 415.9,-24 415.9,-24 421.9,-24 427.9,-30 427.9,-36 427.9,-36 427.9,-48 427.9,-48 427.9,-54 421.9,-60 415.9,-60"/>
+<text xml:space="preserve" text-anchor="middle" x="397" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">index</text>
 </a>
 </g>
 </g>
 <!-- docgen.book.build&#45;&gt;docgen.emitters.index -->
-<g id="edge6" class="edge imports">
+<g id="edge7" class="edge imports">
 <title>docgen.book.build&#45;&gt;docgen.emitters.index</title>
-<path fill="none" stroke="#4a4a4a" d="M635.43,-200.51C636.46,-176.1 635.1,-131.34 615.06,-100.5 603.11,-82.1 582.97,-68.3 564.97,-58.84"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="566.11,-57.06 559.81,-56.23 564.22,-60.81 566.11,-57.06"/>
+<path fill="none" stroke="#4a4a4a" d="M1031.13,-296.98C921.34,-296.65 540.41,-293.4 423,-264 329.17,-240.51 277.86,-253.15 226,-171.5 207.77,-142.8 205.66,-122.25 226,-95 258.72,-51.16 291.73,-76.13 344,-60 348.71,-58.54 353.66,-56.99 358.55,-55.44"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="359.13,-57.46 364.21,-53.64 357.85,-53.46 359.13,-57.46"/>
 </g>
 <!-- docgen.emitters.minimap -->
 <g id="docgen.emitters.minimap" class="node module">
 <title>docgen.emitters.minimap</title>
 <g id="a_docgen.emitters.minimap"><a xlink:href="emitters/minimap.py" xlink:title="IR &#45;&gt; a structural minimap. What is where, readable without reading.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M348.71,-60C348.71,-60 291.41,-60 291.41,-60 285.41,-60 279.41,-54 279.41,-48 279.41,-48 279.41,-36 279.41,-36 279.41,-30 285.41,-24 291.41,-24 291.41,-24 348.71,-24 348.71,-24 354.71,-24 360.71,-30 360.71,-36 360.71,-36 360.71,-48 360.71,-48 360.71,-54 354.71,-60 348.71,-60"/>
-<text xml:space="preserve" text-anchor="middle" x="320.06" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">minimap</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M313.65,-60C313.65,-60 256.35,-60 256.35,-60 250.35,-60 244.35,-54 244.35,-48 244.35,-48 244.35,-36 244.35,-36 244.35,-30 250.35,-24 256.35,-24 256.35,-24 313.65,-24 313.65,-24 319.65,-24 325.65,-30 325.65,-36 325.65,-36 325.65,-48 325.65,-48 325.65,-54 319.65,-60 313.65,-60"/>
+<text xml:space="preserve" text-anchor="middle" x="285" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">minimap</text>
 </a>
 </g>
 </g>
 <!-- docgen.book.build&#45;&gt;docgen.emitters.minimap -->
-<g id="edge7" class="edge imports">
-<title>docgen.book.build&#45;&gt;docgen.emitters.minimap</title>
-<path fill="none" stroke="#4a4a4a" d="M622.64,-200.5C618.32,-193.4 613.6,-184.99 610.06,-177 595.64,-144.42 614.37,-122.14 586.06,-100.5 567.78,-86.52 400.54,-100.79 379.06,-92.5 364.19,-86.76 350.38,-75.63 339.86,-65.38"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="341.44,-64 335.73,-61.2 338.46,-66.95 341.44,-64"/>
-</g>
-<!-- docgen.emitters.notebook -->
-<g id="docgen.emitters.notebook" class="node module">
-<title>docgen.emitters.notebook</title>
-<g id="a_docgen.emitters.notebook"><a xlink:href="emitters/notebook.py" xlink:title="IR &#45;&gt; a Jupyter notebook. Generated, never hand&#45;authored.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M556.34,-144.5C556.34,-144.5 493.79,-144.5 493.79,-144.5 487.79,-144.5 481.79,-138.5 481.79,-132.5 481.79,-132.5 481.79,-120.5 481.79,-120.5 481.79,-114.5 487.79,-108.5 493.79,-108.5 493.79,-108.5 556.34,-108.5 556.34,-108.5 562.34,-108.5 568.34,-114.5 568.34,-120.5 568.34,-120.5 568.34,-132.5 568.34,-132.5 568.34,-138.5 562.34,-144.5 556.34,-144.5"/>
-<text xml:space="preserve" text-anchor="middle" x="525.06" y="-122.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">notebook</text>
-</a>
-</g>
-</g>
-<!-- docgen.book.build&#45;&gt;docgen.emitters.notebook -->
 <g id="edge8" class="edge imports">
-<title>docgen.book.build&#45;&gt;docgen.emitters.notebook</title>
-<path fill="none" stroke="#4a4a4a" d="M606.91,-200.58C596.64,-193.62 585.04,-185.3 575.06,-177 565.11,-168.72 554.82,-158.81 546.19,-150.04"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="547.79,-148.67 542.1,-145.84 544.78,-151.6 547.79,-148.67"/>
-</g>
-<!-- docgen.emitters.site -->
-<g id="docgen.emitters.site" class="node module">
-<title>docgen.emitters.site</title>
-<g id="a_docgen.emitters.site"><a xlink:href="emitters/site.py" xlink:title="IR &#45;&gt; a self&#45;contained documentation site: sidebar, content, graph viewer.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M434.06,-144.5C434.06,-144.5 404.06,-144.5 404.06,-144.5 398.06,-144.5 392.06,-138.5 392.06,-132.5 392.06,-132.5 392.06,-120.5 392.06,-120.5 392.06,-114.5 398.06,-108.5 404.06,-108.5 404.06,-108.5 434.06,-108.5 434.06,-108.5 440.06,-108.5 446.06,-114.5 446.06,-120.5 446.06,-120.5 446.06,-132.5 446.06,-132.5 446.06,-138.5 440.06,-144.5 434.06,-144.5"/>
-<text xml:space="preserve" text-anchor="middle" x="419.06" y="-122.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">site</text>
-</a>
-</g>
-</g>
-<!-- docgen.book.build&#45;&gt;docgen.emitters.site -->
-<g id="edge9" class="edge imports">
-<title>docgen.book.build&#45;&gt;docgen.emitters.site</title>
-<path fill="none" stroke="#4a4a4a" d="M604.4,-206.02C585.44,-198.84 560.16,-190.13 537.06,-185 505.2,-177.92 493.15,-191.81 464.06,-177 452.24,-170.98 442,-160.47 434.29,-150.68"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="436.01,-149.47 430.74,-145.93 432.65,-151.99 436.01,-149.47"/>
+<title>docgen.book.build&#45;&gt;docgen.emitters.minimap</title>
+<path fill="none" stroke="#4a4a4a" d="M1031.48,-296.83C886.51,-295.9 255.66,-290.32 224,-264 165.79,-215.62 166.53,-161.32 203,-95 210.75,-80.91 224.11,-70.1 237.82,-62.08"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="238.57,-64.07 242.8,-59.33 236.54,-60.39 238.57,-64.07"/>
 </g>
 <!-- docgen.ir.model -->
 <g id="docgen.ir.model" class="node module">
 <title>docgen.ir.model</title>
 <g id="a_docgen.ir.model"><a xlink:href="ir/model.py" xlink:title="The IR, as Python. Mirrors `schema.json`, which is the contract.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1744.21,-144.5C1744.21,-144.5 1701.91,-144.5 1701.91,-144.5 1695.91,-144.5 1689.91,-138.5 1689.91,-132.5 1689.91,-132.5 1689.91,-120.5 1689.91,-120.5 1689.91,-114.5 1695.91,-108.5 1701.91,-108.5 1701.91,-108.5 1744.21,-108.5 1744.21,-108.5 1750.21,-108.5 1756.21,-114.5 1756.21,-120.5 1756.21,-120.5 1756.21,-132.5 1756.21,-132.5 1756.21,-138.5 1750.21,-144.5 1744.21,-144.5"/>
-<text xml:space="preserve" text-anchor="middle" x="1723.06" y="-122.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">model</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1839.15,-139C1839.15,-139 1796.85,-139 1796.85,-139 1790.85,-139 1784.85,-133 1784.85,-127 1784.85,-127 1784.85,-115 1784.85,-115 1784.85,-109 1790.85,-103 1796.85,-103 1796.85,-103 1839.15,-103 1839.15,-103 1845.15,-103 1851.15,-109 1851.15,-115 1851.15,-115 1851.15,-127 1851.15,-127 1851.15,-133 1845.15,-139 1839.15,-139"/>
+<text xml:space="preserve" text-anchor="middle" x="1818" y="-117.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">model</text>
 </a>
 </g>
 </g>
 <!-- docgen.book.build&#45;&gt;docgen.ir.model -->
-<g id="edge10" class="edge imports">
+<g id="edge9" class="edge imports">
 <title>docgen.book.build&#45;&gt;docgen.ir.model</title>
-<path fill="none" stroke="#4a4a4a" d="M646.62,-200.72C652.13,-194.57 659.15,-188.34 667.06,-185 683.47,-178.08 1290.29,-178.17 1308.06,-177 1437.61,-168.49 1588.79,-147.7 1668.09,-135.95"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1667.94,-138.09 1673.57,-135.13 1667.32,-133.94 1667.94,-138.09"/>
+<path fill="none" stroke="#4a4a4a" d="M1080.08,-279.51C1084.38,-276.47 1089.12,-273.74 1094,-272 1140.5,-255.44 1267.43,-272.83 1316,-264 1432.22,-242.88 1454.3,-211.55 1568,-179.5 1634.31,-160.81 1711.77,-143.71 1762.69,-133.1"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1763.07,-135.17 1768.52,-131.89 1762.22,-131.06 1763.07,-135.17"/>
 </g>
 <!-- docgen.notebook.spec -->
 <g id="docgen.notebook.spec" class="node module">
 <title>docgen.notebook.spec</title>
 <g id="a_docgen.notebook.spec"><a xlink:href="notebook/spec.py" xlink:title="The notebook, as a sequence — before it is a `.ipynb`.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M102.71,-144.5C102.71,-144.5 69.41,-144.5 69.41,-144.5 63.41,-144.5 57.41,-138.5 57.41,-132.5 57.41,-132.5 57.41,-120.5 57.41,-120.5 57.41,-114.5 63.41,-108.5 69.41,-108.5 69.41,-108.5 102.71,-108.5 102.71,-108.5 108.71,-108.5 114.71,-114.5 114.71,-120.5 114.71,-120.5 114.71,-132.5 114.71,-132.5 114.71,-138.5 108.71,-144.5 102.71,-144.5"/>
-<text xml:space="preserve" text-anchor="middle" x="86.06" y="-122.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">spec</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M852.65,-139C852.65,-139 819.35,-139 819.35,-139 813.35,-139 807.35,-133 807.35,-127 807.35,-127 807.35,-115 807.35,-115 807.35,-109 813.35,-103 819.35,-103 819.35,-103 852.65,-103 852.65,-103 858.65,-103 864.65,-109 864.65,-115 864.65,-115 864.65,-127 864.65,-127 864.65,-133 858.65,-139 852.65,-139"/>
+<text xml:space="preserve" text-anchor="middle" x="836" y="-117.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">spec</text>
 </a>
 </g>
 </g>
 <!-- docgen.book.build&#45;&gt;docgen.notebook.spec -->
-<g id="edge11" class="edge imports">
+<g id="edge10" class="edge imports">
 <title>docgen.book.build&#45;&gt;docgen.notebook.spec</title>
-<path fill="none" stroke="#4a4a4a" d="M604.54,-205.32C585.63,-197.86 560.36,-189.12 537.06,-185 497.12,-177.94 211.14,-187.9 172.06,-177 159.54,-173.51 146.93,-167.77 135.37,-161.42"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="136.63,-159.72 130.38,-158.59 134.56,-163.37 136.63,-159.72"/>
+<path fill="none" stroke="#4a4a4a" d="M1031.34,-294.32C1005.55,-290.78 968.17,-282.64 941,-264 932,-257.82 900.51,-214.57 874.35,-177.4"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="876.24,-176.44 871.07,-172.73 872.8,-178.85 876.24,-176.44"/>
 </g>
 <!-- docgen.ops.filter -->
 <g id="docgen.ops.filter" class="node module">
 <title>docgen.ops.filter</title>
 <g id="a_docgen.ops.filter"><a xlink:href="ops/filter.py" xlink:title="Views: IR in, smaller IR out.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M800.46,-60C800.46,-60 765.66,-60 765.66,-60 759.66,-60 753.66,-54 753.66,-48 753.66,-48 753.66,-36 753.66,-36 753.66,-30 759.66,-24 765.66,-24 765.66,-24 800.46,-24 800.46,-24 806.46,-24 812.46,-30 812.46,-36 812.46,-36 812.46,-48 812.46,-48 812.46,-54 806.46,-60 800.46,-60"/>
-<text xml:space="preserve" text-anchor="middle" x="783.06" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">filter</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M948.4,-60C948.4,-60 913.6,-60 913.6,-60 907.6,-60 901.6,-54 901.6,-48 901.6,-48 901.6,-36 901.6,-36 901.6,-30 907.6,-24 913.6,-24 913.6,-24 948.4,-24 948.4,-24 954.4,-24 960.4,-30 960.4,-36 960.4,-36 960.4,-48 960.4,-48 960.4,-54 954.4,-60 948.4,-60"/>
+<text xml:space="preserve" text-anchor="middle" x="931" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">filter</text>
 </a>
 </g>
 </g>
 <!-- docgen.book.build&#45;&gt;docgen.ops.filter -->
-<g id="edge12" class="edge imports">
+<g id="edge11" class="edge imports">
 <title>docgen.book.build&#45;&gt;docgen.ops.filter</title>
-<path fill="none" stroke="#4a4a4a" d="M663.75,-217.31C693.8,-214.9 739.27,-206.25 764.06,-177 781.9,-155.95 787.37,-126.03 788.07,-99.79"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="790.17,-100.03 788.13,-94.01 785.97,-99.99 790.17,-100.03"/>
+<path fill="none" stroke="#4a4a4a" d="M1090.86,-290.94C1109.97,-286 1134.54,-277.56 1153,-264 1218.51,-215.86 1275.21,-157.32 1223,-95 1192.71,-58.84 1056.25,-47.81 981.08,-44.45"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="981.59,-42.37 975.51,-44.22 981.41,-46.57 981.59,-42.37"/>
+</g>
+<!-- docgen.ops.pages -->
+<g id="docgen.ops.pages" class="node module">
+<title>docgen.ops.pages</title>
+<g id="a_docgen.ops.pages"><a xlink:href="ops/pages.py" xlink:title="Pages: a graph too big for one picture, as a set of pictures that each fit.">
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M953.77,-139C953.77,-139 912.23,-139 912.23,-139 906.23,-139 900.23,-133 900.23,-127 900.23,-127 900.23,-115 900.23,-115 900.23,-109 906.23,-103 912.23,-103 912.23,-103 953.77,-103 953.77,-103 959.77,-103 965.77,-109 965.77,-115 965.77,-115 965.77,-127 965.77,-127 965.77,-133 959.77,-139 953.77,-139"/>
+<text xml:space="preserve" text-anchor="middle" x="933" y="-117.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">pages</text>
+</a>
+</g>
+</g>
+<!-- docgen.book.build&#45;&gt;docgen.ops.pages -->
+<g id="edge12" class="edge imports">
+<title>docgen.book.build&#45;&gt;docgen.ops.pages</title>
+<path fill="none" stroke="#4a4a4a" d="M1031.2,-286.63C1019.37,-281.34 1006.38,-273.89 997,-264 964.78,-230.04 946.87,-177.07 938.65,-146.33"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="940.77,-146.14 937.24,-140.86 936.7,-147.19 940.77,-146.14"/>
 </g>
 <!-- docgen.style.extract -->
 <g id="docgen.style.extract" class="node module">
 <title>docgen.style.extract</title>
 <g id="a_docgen.style.extract"><a xlink:href="style/extract.py" xlink:title="A folder of exported diagrams &#45;&gt; the style vocabulary they use.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1278.59,-144.5C1278.59,-144.5 1229.54,-144.5 1229.54,-144.5 1223.54,-144.5 1217.54,-138.5 1217.54,-132.5 1217.54,-132.5 1217.54,-120.5 1217.54,-120.5 1217.54,-114.5 1223.54,-108.5 1229.54,-108.5 1229.54,-108.5 1278.59,-108.5 1278.59,-108.5 1284.59,-108.5 1290.59,-114.5 1290.59,-120.5 1290.59,-120.5 1290.59,-132.5 1290.59,-132.5 1290.59,-138.5 1284.59,-144.5 1278.59,-144.5"/>
-<text xml:space="preserve" text-anchor="middle" x="1254.06" y="-122.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">extract</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1488.53,-139C1488.53,-139 1439.47,-139 1439.47,-139 1433.47,-139 1427.47,-133 1427.47,-127 1427.47,-127 1427.47,-115 1427.47,-115 1427.47,-109 1433.47,-103 1439.47,-103 1439.47,-103 1488.53,-103 1488.53,-103 1494.53,-103 1500.53,-109 1500.53,-115 1500.53,-115 1500.53,-127 1500.53,-127 1500.53,-133 1494.53,-139 1488.53,-139"/>
+<text xml:space="preserve" text-anchor="middle" x="1464" y="-117.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">extract</text>
 </a>
 </g>
 </g>
 <!-- docgen.book.build&#45;&gt;docgen.style.extract -->
 <g id="edge13" class="edge imports">
 <title>docgen.book.build&#45;&gt;docgen.style.extract</title>
-<path fill="none" stroke="#4a4a4a" d="M647.03,-200.58C652.5,-194.57 659.38,-188.47 667.06,-185 692.63,-173.45 765.11,-179.39 793.06,-177 941.58,-164.32 1116.44,-144.08 1201.83,-133.86"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1201.85,-135.97 1207.56,-133.17 1201.35,-131.8 1201.85,-135.97"/>
+<path fill="none" stroke="#4a4a4a" d="M1080.11,-279.6C1084.41,-276.56 1089.15,-273.79 1094,-272 1149.96,-251.32 1171.01,-281.67 1228,-264 1297.34,-242.5 1367.45,-196.56 1413.02,-162.72"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1414.25,-164.43 1417.79,-159.15 1411.73,-161.06 1414.25,-164.43"/>
 </g>
 <!-- docgen.book.checks -->
 <g id="docgen.book.checks" class="node module">
 <title>docgen.book.checks</title>
 <g id="a_docgen.book.checks"><a xlink:href="book/checks.py" xlink:title="Does *this* book still hold — the third test level.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M753.84,-316C753.84,-316 706.29,-316 706.29,-316 700.29,-316 694.29,-310 694.29,-304 694.29,-304 694.29,-292 694.29,-292 694.29,-286 700.29,-280 706.29,-280 706.29,-280 753.84,-280 753.84,-280 759.84,-280 765.84,-286 765.84,-292 765.84,-292 765.84,-304 765.84,-304 765.84,-310 759.84,-316 753.84,-316"/>
-<text xml:space="preserve" text-anchor="middle" x="730.06" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">checks</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1086.78,-433C1086.78,-433 1039.22,-433 1039.22,-433 1033.22,-433 1027.22,-427 1027.22,-421 1027.22,-421 1027.22,-409 1027.22,-409 1027.22,-403 1033.22,-397 1039.22,-397 1039.22,-397 1086.78,-397 1086.78,-397 1092.78,-397 1098.78,-403 1098.78,-409 1098.78,-409 1098.78,-421 1098.78,-421 1098.78,-427 1092.78,-433 1086.78,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="1063" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">checks</text>
 </a>
 </g>
 </g>
 <!-- docgen.book.checks&#45;&gt;docgen.book.build -->
 <g id="edge14" class="edge imports">
 <title>docgen.book.checks&#45;&gt;docgen.book.build</title>
-<path fill="none" stroke="#4a4a4a" d="M708.28,-279.53C694.41,-268.4 676.33,-253.9 661.48,-241.99"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="662.94,-240.47 656.94,-238.35 660.31,-243.74 662.94,-240.47"/>
+<path fill="none" stroke="#4a4a4a" d="M1062.7,-396.53C1062.36,-377.09 1061.81,-345.51 1061.43,-323.57"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1063.53,-323.73 1061.33,-317.77 1059.33,-323.8 1063.53,-323.73"/>
 </g>
 <!-- docgen.book.config -->
 <g id="docgen.book.config" class="node module">
 <title>docgen.book.config</title>
 <g id="a_docgen.book.config"><a xlink:href="book/config.py" xlink:title="A run file: every book a project builds, so a rebuild is one command.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M646.21,-316C646.21,-316 603.91,-316 603.91,-316 597.91,-316 591.91,-310 591.91,-304 591.91,-304 591.91,-292 591.91,-292 591.91,-286 597.91,-280 603.91,-280 603.91,-280 646.21,-280 646.21,-280 652.21,-280 658.21,-286 658.21,-292 658.21,-292 658.21,-304 658.21,-304 658.21,-310 652.21,-316 646.21,-316"/>
-<text xml:space="preserve" text-anchor="middle" x="625.06" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">config</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1192.15,-433C1192.15,-433 1149.85,-433 1149.85,-433 1143.85,-433 1137.85,-427 1137.85,-421 1137.85,-421 1137.85,-409 1137.85,-409 1137.85,-403 1143.85,-397 1149.85,-397 1149.85,-397 1192.15,-397 1192.15,-397 1198.15,-397 1204.15,-403 1204.15,-409 1204.15,-409 1204.15,-421 1204.15,-421 1204.15,-427 1198.15,-433 1192.15,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="1171" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">config</text>
 </a>
 </g>
 </g>
 <!-- docgen.book.config&#45;&gt;docgen.__main__ -->
 <g id="edge15" class="edge imports">
 <title>docgen.book.config&#45;&gt;docgen.__main__</title>
-<path fill="none" stroke="#4a4a4a" d="M657.13,-279.54C663.28,-276.7 669.77,-274.02 676.06,-272 766.72,-242.89 877.75,-229.33 939.62,-223.63"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="939.62,-225.74 945.41,-223.11 939.24,-221.56 939.62,-225.74"/>
+<path fill="none" stroke="#4a4a4a" d="M1200.45,-396.67C1207.74,-391.92 1215.36,-386.54 1222,-381 1243.55,-363.01 1265.18,-339.37 1280,-322.09"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1281.49,-323.58 1283.78,-317.65 1278.29,-320.86 1281.49,-323.58"/>
 </g>
 <!-- docgen.book.config&#45;&gt;docgen.book.build -->
 <g id="edge16" class="edge imports">
 <title>docgen.book.config&#45;&gt;docgen.book.build</title>
-<path fill="none" stroke="#4a4a4a" d="M615.58,-279.53C614.62,-269.19 615.79,-255.94 618.51,-244.56"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="620.51,-245.2 620.11,-238.86 616.47,-244.07 620.51,-245.2"/>
+<path fill="none" stroke="#4a4a4a" d="M1137.52,-397.24C1131.65,-392.05 1126.09,-386.3 1121,-381 1101.97,-361.19 1080.46,-338.55 1067.79,-322.09"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1069.68,-321.13 1064.44,-317.54 1066.3,-323.62 1069.68,-321.13"/>
 </g>
 <!-- docgen.book.config&#45;&gt;docgen.book.build -->
 <g id="edge17" class="edge imports">
 <title>docgen.book.config&#45;&gt;docgen.book.build</title>
-<path fill="none" stroke="#4a4a4a" d="M638.63,-279.53C641.97,-269.29 643.9,-256.19 643.87,-244.88"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="645.97,-244.81 643.6,-238.92 641.78,-245 645.97,-244.81"/>
+<path fill="none" stroke="#4a4a4a" d="M1171.3,-396.56C1167.17,-391.55 1161.86,-386.07 1157,-381 1137.34,-360.53 1115.04,-337.06 1096.1,-320.49"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1097.93,-319.29 1092.01,-316.99 1095.2,-322.48 1097.93,-319.29"/>
 </g>
-<!-- docgen.book.config&#45;&gt;docgen.notebook.spec -->
+<!-- docgen.book.config&#45;&gt;docgen.book.document -->
 <g id="edge18" class="edge imports">
+<title>docgen.book.config&#45;&gt;docgen.book.document</title>
+<path fill="none" stroke="#4a4a4a" d="M1165.07,-396.62C1155.29,-369.06 1134.22,-314.13 1108,-272 1100.41,-259.8 1090.42,-247.41 1081.53,-237.28"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1083.29,-236.1 1077.73,-233.02 1080.16,-238.9 1083.29,-236.1"/>
+</g>
+<!-- docgen.extractors.code -->
+<g id="docgen.extractors.code" class="node module">
+<title>docgen.extractors.code</title>
+<g id="a_docgen.extractors.code"><a xlink:href="extractors/code.py" xlink:title="Source in several languages &#45;&gt; IR structure, via **tree&#45;sitter**.">
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1737.03,-316C1737.03,-316 1702.97,-316 1702.97,-316 1696.97,-316 1690.97,-310 1690.97,-304 1690.97,-304 1690.97,-292 1690.97,-292 1690.97,-286 1696.97,-280 1702.97,-280 1702.97,-280 1737.03,-280 1737.03,-280 1743.03,-280 1749.03,-286 1749.03,-292 1749.03,-292 1749.03,-304 1749.03,-304 1749.03,-310 1743.03,-316 1737.03,-316"/>
+<text xml:space="preserve" text-anchor="middle" x="1720" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">code</text>
+</a>
+</g>
+</g>
+<!-- docgen.book.config&#45;&gt;docgen.extractors.code -->
+<g id="edge19" class="edge imports">
+<title>docgen.book.config&#45;&gt;docgen.extractors.code</title>
+<path fill="none" stroke="#4a4a4a" d="M1204.59,-413.9C1312.87,-413.3 1648.04,-409.17 1687,-381 1705.33,-367.74 1713.5,-342.56 1717.12,-323.58"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1719.15,-324.16 1718.09,-317.89 1715.01,-323.45 1719.15,-324.16"/>
+</g>
+<!-- docgen.book.config&#45;&gt;docgen.notebook.spec -->
+<g id="edge20" class="edge imports">
 <title>docgen.book.config&#45;&gt;docgen.notebook.spec</title>
-<path fill="none" stroke="#4a4a4a" d="M591.46,-286.89C521.61,-266.08 355.47,-217.68 214.06,-185 195.55,-180.72 189.88,-183.61 172.06,-177 159.72,-172.42 147.08,-166.16 135.43,-159.64"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="136.62,-157.91 130.37,-156.75 134.54,-161.55 136.62,-157.91"/>
+<path fill="none" stroke="#4a4a4a" d="M1138.93,-396.56C1131.89,-393.48 1124.35,-390.71 1117,-389 1098.65,-384.73 791.16,-394.48 778,-381 715.43,-316.93 743.55,-262.16 778,-179.5 780.57,-173.33 784.16,-167.49 788.31,-162.05"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="789.86,-163.47 792.04,-157.49 786.62,-160.8 789.86,-163.47"/>
+</g>
+<!-- docgen.book.document&#45;&gt;docgen.book.build -->
+<g id="edge21" class="edge imports">
+<title>docgen.book.document&#45;&gt;docgen.book.build</title>
+<path fill="none" stroke="#4a4a4a" d="M1060.21,-231.97C1060.35,-243.67 1060.54,-259.24 1060.7,-272.21"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1058.6,-272.02 1060.77,-277.99 1062.8,-271.97 1058.6,-272.02"/>
+</g>
+<!-- docgen.book.document&#45;&gt;docgen.book.build -->
+<g id="edge22" class="edge imports">
+<title>docgen.book.document&#45;&gt;docgen.book.build</title>
+<path fill="none" stroke="#4a4a4a" d="M1082.74,-231.97C1087.91,-243.78 1088.89,-259.53 1085.6,-272.58"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1083.67,-271.71 1083.8,-278.07 1087.67,-273.02 1083.67,-271.71"/>
+</g>
+<!-- docgen.book.document&#45;&gt;docgen.book.larder -->
+<g id="edge23" class="edge imports">
+<title>docgen.book.document&#45;&gt;docgen.book.larder</title>
+<path fill="none" stroke="#4a4a4a" d="M1088.91,-195.05C1099.63,-188.16 1111.68,-179.88 1122,-171.5 1132.05,-163.34 1142.35,-153.45 1150.97,-144.66"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1152.38,-146.21 1155.05,-140.44 1149.37,-143.29 1152.38,-146.21"/>
+</g>
+<!-- docgen.book.notes -->
+<g id="docgen.book.notes" class="node module">
+<title>docgen.book.notes</title>
+<g id="a_docgen.book.notes"><a xlink:href="book/notes.py" xlink:title="Notes: hand&#45;written markdown, filed by the page or step it belongs above.">
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1091.65,-139C1091.65,-139 1052.35,-139 1052.35,-139 1046.35,-139 1040.35,-133 1040.35,-127 1040.35,-127 1040.35,-115 1040.35,-115 1040.35,-109 1046.35,-103 1052.35,-103 1052.35,-103 1091.65,-103 1091.65,-103 1097.65,-103 1103.65,-109 1103.65,-115 1103.65,-115 1103.65,-127 1103.65,-127 1103.65,-133 1097.65,-139 1091.65,-139"/>
+<text xml:space="preserve" text-anchor="middle" x="1072" y="-117.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">notes</text>
+</a>
+</g>
+</g>
+<!-- docgen.book.document&#45;&gt;docgen.book.notes -->
+<g id="edge24" class="edge imports">
+<title>docgen.book.document&#45;&gt;docgen.book.notes</title>
+<path fill="none" stroke="#4a4a4a" d="M1062.31,-195.05C1064.14,-181.28 1066.71,-161.9 1068.74,-146.56"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1070.79,-147.12 1069.49,-140.9 1066.62,-146.57 1070.79,-147.12"/>
+</g>
+<!-- docgen.book.document&#45;&gt;docgen.emitters.auto -->
+<g id="edge25" class="edge imports">
+<title>docgen.book.document&#45;&gt;docgen.emitters.auto</title>
+<path fill="none" stroke="#4a4a4a" d="M1014.77,-202.64C977.26,-194.91 922.43,-184.63 874,-179.5 860.53,-178.07 802.38,-178.89 748.26,-178.3"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="748.54,-176.2 742.51,-178.23 748.49,-180.4 748.54,-176.2"/>
+</g>
+<!-- docgen.emitters.notebook -->
+<g id="docgen.emitters.notebook" class="node module">
+<title>docgen.emitters.notebook</title>
+<g id="a_docgen.emitters.notebook"><a xlink:href="emitters/notebook.py" xlink:title="IR &#45;&gt; a Jupyter notebook. Generated, never hand&#45;authored.">
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M625.27,-231.5C625.27,-231.5 562.73,-231.5 562.73,-231.5 556.73,-231.5 550.73,-225.5 550.73,-219.5 550.73,-219.5 550.73,-207.5 550.73,-207.5 550.73,-201.5 556.73,-195.5 562.73,-195.5 562.73,-195.5 625.27,-195.5 625.27,-195.5 631.27,-195.5 637.27,-201.5 637.27,-207.5 637.27,-207.5 637.27,-219.5 637.27,-219.5 637.27,-225.5 631.27,-231.5 625.27,-231.5"/>
+<text xml:space="preserve" text-anchor="middle" x="594" y="-209.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">notebook</text>
+</a>
+</g>
+</g>
+<!-- docgen.book.document&#45;&gt;docgen.emitters.notebook -->
+<g id="edge26" class="edge imports">
+<title>docgen.book.document&#45;&gt;docgen.emitters.notebook</title>
+<path fill="none" stroke="#4a4a4a" d="M1015.05,-213.5C891.72,-213.5 768.39,-213.5 645.06,-213.5"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="645.2,-211.4 639.2,-213.5 645.2,-215.6 645.2,-211.4"/>
+</g>
+<!-- docgen.emitters.paged -->
+<g id="docgen.emitters.paged" class="node module">
+<title>docgen.emitters.paged</title>
+<g id="a_docgen.emitters.paged"><a xlink:href="emitters/paged.py" xlink:title="Draw pages: measure each one against a width, then render it for an output.">
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M721.15,-139C721.15,-139 678.85,-139 678.85,-139 672.85,-139 666.85,-133 666.85,-127 666.85,-127 666.85,-115 666.85,-115 666.85,-109 672.85,-103 678.85,-103 678.85,-103 721.15,-103 721.15,-103 727.15,-103 733.15,-109 733.15,-115 733.15,-115 733.15,-127 733.15,-127 733.15,-133 727.15,-139 721.15,-139"/>
+<text xml:space="preserve" text-anchor="middle" x="700" y="-117.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">paged</text>
+</a>
+</g>
+</g>
+<!-- docgen.book.document&#45;&gt;docgen.emitters.paged -->
+<g id="edge27" class="edge imports">
+<title>docgen.book.document&#45;&gt;docgen.emitters.paged</title>
+<path fill="none" stroke="#4a4a4a" d="M1015.07,-203.4C977.5,-196.06 922.44,-185.94 874,-179.5 834.19,-174.21 822.24,-183.77 784,-171.5 764.36,-165.2 744.39,-153.68 728.85,-143.35"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="730.31,-141.79 724.16,-140.16 727.94,-145.27 730.31,-141.79"/>
+</g>
+<!-- docgen.book.document&#45;&gt;docgen.notebook.spec -->
+<g id="edge28" class="edge imports">
+<title>docgen.book.document&#45;&gt;docgen.notebook.spec</title>
+<path fill="none" stroke="#4a4a4a" d="M1028.28,-195.02C1016.05,-189.08 1001.71,-183.04 988,-179.5 967.11,-174.1 913.46,-180.39 884.73,-171.44"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="885.76,-169.59 879.41,-169.37 884.24,-173.5 885.76,-169.59"/>
+</g>
+<!-- docgen.book.document&#45;&gt;docgen.ops.filter -->
+<g id="edge29" class="edge imports">
+<title>docgen.book.document&#45;&gt;docgen.ops.filter</title>
+<path fill="none" stroke="#4a4a4a" d="M1041.78,-195.09C1035.08,-188.13 1027.73,-179.81 1022,-171.5 1000.43,-140.26 1006.3,-125.72 984,-95 982.29,-92.64 980.46,-90.29 978.56,-87.97"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="980.47,-86.97 974.98,-83.77 977.27,-89.69 980.47,-86.97"/>
+</g>
+<!-- docgen.book.document&#45;&gt;docgen.ops.pages -->
+<g id="edge30" class="edge imports">
+<title>docgen.book.document&#45;&gt;docgen.ops.pages</title>
+<path fill="none" stroke="#4a4a4a" d="M1029.4,-195.01C1017.77,-188.05 1004.55,-179.73 993,-171.5 981.22,-163.1 968.79,-153.06 958.31,-144.22"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="959.8,-142.73 953.87,-140.44 957.08,-145.92 959.8,-142.73"/>
+</g>
+<!-- docgen.book.document&#45;&gt;docgen.style.extract -->
+<g id="edge31" class="edge imports">
+<title>docgen.book.document&#45;&gt;docgen.style.extract</title>
+<path fill="none" stroke="#4a4a4a" d="M1105.17,-202.38C1180.68,-185.47 1332.12,-151.54 1411.97,-133.65"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1412.13,-135.77 1417.53,-132.41 1411.21,-131.67 1412.13,-135.77"/>
 </g>
 <!-- docgen.cli.book&#45;&gt;docgen.book.build -->
-<g id="edge20" class="edge imports">
+<g id="edge33" class="edge imports">
 <title>docgen.cli.book&#45;&gt;docgen.book.build</title>
-<path fill="none" stroke="#4a4a4a" d="M979.21,-396.58C941.44,-367.22 860.62,-307.58 784.06,-272 736.96,-250.11 718.96,-256.65 670.52,-238.27"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="671.57,-236.42 665.22,-236.19 670.04,-240.33 671.57,-236.42"/>
+<path fill="none" stroke="#4a4a4a" d="M2172.94,-396.6C2166.6,-393.48 2159.75,-390.68 2153,-389 2124.45,-381.9 1118.31,-397.56 1094,-381 1075.19,-368.19 1067.1,-342.7 1063.62,-323.52"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1065.72,-323.35 1062.7,-317.76 1061.57,-324.01 1065.72,-323.35"/>
 </g>
 <!-- docgen.cli.common -->
 <g id="docgen.cli.common" class="node module">
 <title>docgen.cli.common</title>
 <g id="a_docgen.cli.common"><a xlink:href="cli/common.py" xlink:title="What every command does the same way — written once.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1196.34,-316C1196.34,-316 1139.79,-316 1139.79,-316 1133.79,-316 1127.79,-310 1127.79,-304 1127.79,-304 1127.79,-292 1127.79,-292 1127.79,-286 1133.79,-280 1139.79,-280 1139.79,-280 1196.34,-280 1196.34,-280 1202.34,-280 1208.34,-286 1208.34,-292 1208.34,-292 1208.34,-304 1208.34,-304 1208.34,-310 1202.34,-316 1196.34,-316"/>
-<text xml:space="preserve" text-anchor="middle" x="1168.06" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">common</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M2390.28,-316C2390.28,-316 2333.72,-316 2333.72,-316 2327.72,-316 2321.72,-310 2321.72,-304 2321.72,-304 2321.72,-292 2321.72,-292 2321.72,-286 2327.72,-280 2333.72,-280 2333.72,-280 2390.28,-280 2390.28,-280 2396.28,-280 2402.28,-286 2402.28,-292 2402.28,-292 2402.28,-304 2402.28,-304 2402.28,-310 2396.28,-316 2390.28,-316"/>
+<text xml:space="preserve" text-anchor="middle" x="2362" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">common</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.book&#45;&gt;docgen.cli.common -->
-<g id="edge19" class="edge imports">
+<g id="edge32" class="edge imports">
 <title>docgen.cli.book&#45;&gt;docgen.cli.common</title>
-<path fill="none" stroke="#4a4a4a" d="M1012.65,-396.6C1018.32,-393.63 1024.77,-390.9 1031.06,-389 1047.11,-384.16 1092.16,-390.36 1106.06,-381 1126.17,-367.47 1137.83,-341.63 1147.65,-322.56"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1149.26,-324 1150.21,-317.72 1145.55,-322.04 1149.26,-324"/>
+<path fill="none" stroke="#4a4a4a" d="M2215.43,-396.53C2239.63,-376.13 2286.65,-342.36 2321.26,-320.4"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2322.32,-322.21 2326.29,-317.25 2320.09,-318.66 2322.32,-322.21"/>
 </g>
 <!-- docgen.cli.book&#45;&gt;docgen.cli.common -->
-<g id="edge21" class="edge imports">
+<g id="edge34" class="edge imports">
 <title>docgen.cli.book&#45;&gt;docgen.cli.common</title>
-<path fill="none" stroke="#4a4a4a" d="M1030.85,-404.73C1042.61,-399.22 1055.1,-392.61 1067.06,-389 1083.11,-384.16 1128.16,-390.36 1142.06,-381 1161.74,-367.76 1173.31,-342.75 1176.22,-323.81"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1178.31,-324.06 1176.78,-317.89 1174.12,-323.66 1178.31,-324.06"/>
+<path fill="none" stroke="#4a4a4a" d="M2230.74,-399.44C2263.34,-379.69 2313.49,-344.24 2341.87,-321.17"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2343.14,-322.85 2346.42,-317.41 2340.46,-319.62 2343.14,-322.85"/>
 </g>
 <!-- docgen.cli.book&#45;&gt;docgen.notebook.spec -->
-<g id="edge22" class="edge imports">
+<g id="edge35" class="edge imports">
 <title>docgen.cli.book&#45;&gt;docgen.notebook.spec</title>
-<path fill="none" stroke="#4a4a4a" d="M973.36,-396.55C967.22,-393.47 960.59,-390.7 954.06,-389 872.55,-367.75 657.66,-397.57 575.06,-381 403.67,-346.62 357.98,-328.53 209.06,-237 182.31,-220.56 155.87,-198.07 134.41,-177.75"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="135.94,-176.31 130.15,-173.68 133.04,-179.34 135.94,-176.31"/>
+<path fill="none" stroke="#4a4a4a" d="M2172.94,-396.62C2166.6,-393.49 2159.74,-390.69 2153,-389 2132.2,-383.79 1396.77,-395.54 1381,-381 1363.12,-364.51 1388.79,-288.59 1371,-272 1355.84,-257.87 1016.92,-272.46 998,-264 951.06,-243.03 963.65,-204.99 919,-179.5 906.55,-172.39 899.25,-177.78 884.71,-171.75"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="885.66,-169.88 879.35,-169.07 883.78,-173.63 885.66,-169.88"/>
 </g>
 <!-- docgen.cli.check -->
 <g id="docgen.cli.check" class="node module">
 <title>docgen.cli.check</title>
 <g id="a_docgen.cli.check"><a xlink:href="cli/check.py" xlink:title="python3 &#45;m docgen check &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;docgen&#39;s own suite">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1119.46,-433C1119.46,-433 1078.66,-433 1078.66,-433 1072.66,-433 1066.66,-427 1066.66,-421 1066.66,-421 1066.66,-409 1066.66,-409 1066.66,-403 1072.66,-397 1078.66,-397 1078.66,-397 1119.46,-397 1119.46,-397 1125.46,-397 1131.46,-403 1131.46,-409 1131.46,-409 1131.46,-421 1131.46,-421 1131.46,-427 1125.46,-433 1119.46,-433"/>
-<text xml:space="preserve" text-anchor="middle" x="1099.06" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">check</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M2862.4,-433C2862.4,-433 2821.6,-433 2821.6,-433 2815.6,-433 2809.6,-427 2809.6,-421 2809.6,-421 2809.6,-409 2809.6,-409 2809.6,-403 2815.6,-397 2821.6,-397 2821.6,-397 2862.4,-397 2862.4,-397 2868.4,-397 2874.4,-403 2874.4,-409 2874.4,-409 2874.4,-421 2874.4,-421 2874.4,-427 2868.4,-433 2862.4,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="2842" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">check</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.check&#45;&gt;docgen.book.checks -->
-<g id="edge23" class="edge imports">
+<g id="edge36" class="edge imports">
 <title>docgen.cli.check&#45;&gt;docgen.book.checks</title>
-<path fill="none" stroke="#4a4a4a" d="M1068.85,-396.59C1062.2,-393.5 1055.05,-390.73 1048.06,-389 1018.39,-381.66 798.99,-397.2 773.06,-381 752.75,-368.31 741.52,-342.62 735.68,-323.36"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="737.76,-322.99 734.1,-317.79 733.71,-324.14 737.76,-322.99"/>
+<path fill="none" stroke="#4a4a4a" d="M2836.77,-433.23C2828.36,-458.55 2809.11,-503.11 2774,-519.5 2732.82,-538.73 1179.18,-538.73 1138,-519.5 1104.89,-504.04 1083.47,-465.66 1072.32,-439.96"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1074.28,-439.21 1070.03,-434.48 1070.4,-440.83 1074.28,-439.21"/>
 </g>
 <!-- docgen.cli.check&#45;&gt;docgen.cli.common -->
-<g id="edge24" class="edge imports">
+<g id="edge37" class="edge imports">
 <title>docgen.cli.check&#45;&gt;docgen.cli.common</title>
-<path fill="none" stroke="#4a4a4a" d="M1113.08,-396.55C1116.81,-391.63 1120.72,-386.2 1124.06,-381 1136.23,-362.03 1148.2,-339.39 1156.58,-322.71"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1158.25,-324.07 1159.04,-317.76 1154.49,-322.2 1158.25,-324.07"/>
+<path fill="none" stroke="#4a4a4a" d="M2811.51,-396.55C2805.23,-393.59 2798.53,-390.87 2792,-389 2755.52,-378.56 2744.44,-387.18 2707,-381 2599.46,-363.25 2475.65,-330.83 2409.52,-312.52"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2410.32,-310.57 2403.98,-310.98 2409.2,-314.61 2410.32,-310.57"/>
 </g>
 <!-- docgen.cli.common&#45;&gt;docgen.ir.model -->
-<g id="edge25" class="edge imports">
+<g id="edge38" class="edge imports">
 <title>docgen.cli.common&#45;&gt;docgen.ir.model</title>
-<path fill="none" stroke="#4a4a4a" d="M1208.42,-284.67C1306.29,-254.78 1556.38,-178.4 1667.92,-144.34"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1668.49,-146.36 1673.62,-142.6 1667.27,-142.34 1668.49,-146.36"/>
+<path fill="none" stroke="#4a4a4a" d="M2324.71,-279.61C2270.18,-254.7 2165.04,-208.67 2072,-179.5 2004.68,-158.39 1925.05,-141.65 1873.13,-131.8"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1873.77,-129.78 1867.48,-130.73 1872.99,-133.91 1873.77,-129.78"/>
 </g>
 <!-- docgen.cli.common&#45;&gt;docgen.style.extract -->
-<g id="edge26" class="edge imports">
+<g id="edge39" class="edge imports">
 <title>docgen.cli.common&#45;&gt;docgen.style.extract</title>
-<path fill="none" stroke="#4a4a4a" d="M1176.78,-279.81C1188.15,-257.41 1208.59,-217.12 1225.6,-183.6"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1227.42,-184.65 1228.26,-178.35 1223.68,-182.75 1227.42,-184.65"/>
+<path fill="none" stroke="#4a4a4a" d="M2321.24,-292.58C2265.18,-286.7 2161.08,-276.54 2072,-272 2058.02,-271.29 1580.44,-270.43 1568,-264 1532.72,-245.76 1506.46,-209.44 1489.15,-178.1"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1491.01,-177.12 1486.31,-172.83 1487.31,-179.11 1491.01,-177.12"/>
+</g>
+<!-- docgen.cli.contract -->
+<g id="docgen.cli.contract" class="node module">
+<title>docgen.cli.contract</title>
+<g id="a_docgen.cli.contract"><a xlink:href="cli/contract.py" xlink:title="python3 &#45;m docgen contract &gt; docgen&#45;contract.md">
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M2672.28,-433C2672.28,-433 2615.72,-433 2615.72,-433 2609.72,-433 2603.72,-427 2603.72,-421 2603.72,-421 2603.72,-409 2603.72,-409 2603.72,-403 2609.72,-397 2615.72,-397 2615.72,-397 2672.28,-397 2672.28,-397 2678.28,-397 2684.28,-403 2684.28,-409 2684.28,-409 2684.28,-421 2684.28,-421 2684.28,-427 2678.28,-433 2672.28,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="2644" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">contract</text>
+</a>
+</g>
+</g>
+<!-- docgen.cli.contract&#45;&gt;docgen.cli.common -->
+<g id="edge40" class="edge imports">
+<title>docgen.cli.contract&#45;&gt;docgen.cli.common</title>
+<path fill="none" stroke="#4a4a4a" d="M2603.81,-396.52C2597.85,-393.97 2591.77,-391.4 2586,-389 2525.28,-363.72 2454.82,-335.61 2409.38,-317.64"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2410.35,-315.76 2404,-315.51 2408.81,-319.67 2410.35,-315.76"/>
 </g>
 <!-- docgen.cli.emit -->
 <g id="docgen.cli.emit" class="node module">
 <title>docgen.cli.emit</title>
 <g id="a_docgen.cli.emit"><a xlink:href="cli/emit.py" xlink:title="python3 &#45;m docgen emit auto &#160;&#160;&#160;&#160;&lt;ir.json&gt; &#45;o DIR &#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;&#160;whatever the structure asks for">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M834.34,-433C834.34,-433 801.79,-433 801.79,-433 795.79,-433 789.79,-427 789.79,-421 789.79,-421 789.79,-409 789.79,-409 789.79,-403 795.79,-397 801.79,-397 801.79,-397 834.34,-397 834.34,-397 840.34,-397 846.34,-403 846.34,-409 846.34,-409 846.34,-421 846.34,-421 846.34,-427 840.34,-433 834.34,-433"/>
-<text xml:space="preserve" text-anchor="middle" x="818.06" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">emit</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M2123.28,-433C2123.28,-433 2090.72,-433 2090.72,-433 2084.72,-433 2078.72,-427 2078.72,-421 2078.72,-421 2078.72,-409 2078.72,-409 2078.72,-403 2084.72,-397 2090.72,-397 2090.72,-397 2123.28,-397 2123.28,-397 2129.28,-397 2135.28,-403 2135.28,-409 2135.28,-409 2135.28,-421 2135.28,-421 2135.28,-427 2129.28,-433 2123.28,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="2107" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">emit</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.emit&#45;&gt;docgen.cli.common -->
-<g id="edge27" class="edge imports">
+<g id="edge41" class="edge imports">
 <title>docgen.cli.emit&#45;&gt;docgen.cli.common</title>
-<path fill="none" stroke="#4a4a4a" d="M846.63,-396.7C852.26,-393.8 858.24,-391.07 864.06,-389 882.38,-382.5 888.2,-385.7 907.06,-381 982.71,-362.15 1068.64,-333.77 1120.57,-315.82"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1120.95,-317.91 1125.93,-313.96 1119.57,-313.94 1120.95,-317.91"/>
+<path fill="none" stroke="#4a4a4a" d="M2135.65,-398.29C2141.66,-395.13 2148,-391.89 2154,-389 2208.24,-362.89 2271.93,-335.85 2314.41,-318.31"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2315.15,-320.27 2319.9,-316.05 2313.56,-316.39 2315.15,-320.27"/>
 </g>
 <!-- docgen.cli.emit&#45;&gt;docgen.emitters.auto -->
-<g id="edge28" class="edge imports">
+<g id="edge42" class="edge imports">
 <title>docgen.cli.emit&#45;&gt;docgen.emitters.auto</title>
-<path fill="none" stroke="#4a4a4a" d="M789.36,-413.22C705.26,-410.7 463.54,-401.7 435.06,-381 358.62,-325.42 336.42,-204.34 330.28,-152.2"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="332.37,-151.97 329.63,-146.24 328.2,-152.43 332.37,-151.97"/>
+<path fill="none" stroke="#4a4a4a" d="M2078.35,-413.03C1967.88,-409.32 1558.93,-395.9 1222,-389 1187.06,-388.28 626.31,-391.59 593,-381 481.33,-345.51 342.67,-264.8 423,-179.5 433.15,-168.72 542.58,-177.75 556,-171.5 568.39,-165.73 579.16,-155.11 587.25,-145.18"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="588.75,-146.68 590.77,-140.65 585.43,-144.1 588.75,-146.68"/>
 </g>
 <!-- docgen.emitters.dot -->
 <g id="docgen.emitters.dot" class="node module">
 <title>docgen.emitters.dot</title>
 <g id="a_docgen.emitters.dot"><a xlink:href="emitters/dot.py" xlink:title="IR + style &#45;&gt; DOT &#45;&gt; SVG.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M231.06,-60C231.06,-60 201.06,-60 201.06,-60 195.06,-60 189.06,-54 189.06,-48 189.06,-48 189.06,-36 189.06,-36 189.06,-30 195.06,-24 201.06,-24 201.06,-24 231.06,-24 231.06,-24 237.06,-24 243.06,-30 243.06,-36 243.06,-36 243.06,-48 243.06,-48 243.06,-54 237.06,-60 231.06,-60"/>
-<text xml:space="preserve" text-anchor="middle" x="216.06" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">dot</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M615,-60C615,-60 585,-60 585,-60 579,-60 573,-54 573,-48 573,-48 573,-36 573,-36 573,-30 579,-24 585,-24 585,-24 615,-24 615,-24 621,-24 627,-30 627,-36 627,-36 627,-48 627,-48 627,-54 621,-60 615,-60"/>
+<text xml:space="preserve" text-anchor="middle" x="600" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">dot</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.emit&#45;&gt;docgen.emitters.dot -->
-<g id="edge29" class="edge imports">
+<g id="edge43" class="edge imports">
 <title>docgen.cli.emit&#45;&gt;docgen.emitters.dot</title>
-<path fill="none" stroke="#4a4a4a" d="M789.43,-414.36C666.15,-415.67 184.41,-418.33 129.06,-381 20.06,-307.47 -42.57,-206.62 35.06,-100.5 68.58,-54.69 138.88,-44.49 181.32,-42.72"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="181.21,-44.83 187.14,-42.54 181.08,-40.63 181.21,-44.83"/>
+<path fill="none" stroke="#4a4a4a" d="M2078.35,-412.99C1967.89,-409.14 1558.94,-395.29 1222,-389 1209.77,-388.77 351.5,-387.28 341,-381 223.42,-310.69 134.49,-196.96 226,-95 274.22,-41.27 478.46,-75.39 549,-60 554.45,-58.81 560.13,-57.25 565.65,-55.56"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="565.99,-57.65 571.07,-53.82 564.71,-53.65 565.99,-57.65"/>
 </g>
 <!-- docgen.emitters.erd -->
 <g id="docgen.emitters.erd" class="node module">
 <title>docgen.emitters.erd</title>
 <g id="a_docgen.emitters.erd"><a xlink:href="emitters/erd.py" xlink:title="A schema, as an entity&#45;relationship diagram. SVG written directly — no Graphviz.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M439.06,-60C439.06,-60 409.06,-60 409.06,-60 403.06,-60 397.06,-54 397.06,-48 397.06,-48 397.06,-36 397.06,-36 397.06,-30 403.06,-24 409.06,-24 409.06,-24 439.06,-24 439.06,-24 445.06,-24 451.06,-30 451.06,-36 451.06,-36 451.06,-48 451.06,-48 451.06,-54 445.06,-60 439.06,-60"/>
-<text xml:space="preserve" text-anchor="middle" x="424.06" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">erd</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M519,-60C519,-60 489,-60 489,-60 483,-60 477,-54 477,-48 477,-48 477,-36 477,-36 477,-30 483,-24 489,-24 489,-24 519,-24 519,-24 525,-24 531,-30 531,-36 531,-36 531,-48 531,-48 531,-54 525,-60 519,-60"/>
+<text xml:space="preserve" text-anchor="middle" x="504" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">erd</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.emit&#45;&gt;docgen.emitters.erd -->
-<g id="edge30" class="edge imports">
+<g id="edge44" class="edge imports">
 <title>docgen.cli.emit&#45;&gt;docgen.emitters.erd</title>
-<path fill="none" stroke="#4a4a4a" d="M818.94,-396.78C821.57,-337.09 826.72,-140.6 783.06,-100.5 770.58,-89.03 493.78,-98.85 478.06,-92.5 464.13,-86.87 451.56,-75.9 442.06,-65.71"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="443.68,-64.37 438.12,-61.3 440.55,-67.17 443.68,-64.37"/>
+<path fill="none" stroke="#4a4a4a" d="M2078.35,-412.98C1967.89,-409.09 1558.95,-395.09 1222,-389 1207.95,-388.75 221.11,-389.62 210,-381 109.02,-302.65 95.16,-190.59 180,-95 219.58,-50.41 387.66,-72.31 446,-60 453.78,-58.36 462.04,-56.2 469.81,-53.97"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="470.17,-56.05 475.33,-52.35 468.98,-52.03 470.17,-56.05"/>
 </g>
 <!-- docgen.cli.emit&#45;&gt;docgen.emitters.explore -->
-<g id="edge31" class="edge imports">
+<g id="edge45" class="edge imports">
 <title>docgen.cli.emit&#45;&gt;docgen.emitters.explore</title>
-<path fill="none" stroke="#4a4a4a" d="M789.43,-413.62C693.49,-412.11 387.41,-405.42 351.06,-381 340.55,-373.93 265.63,-213.26 237.08,-151.44"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="239.05,-150.69 234.63,-146.12 235.23,-152.45 239.05,-150.69"/>
+<path fill="none" stroke="#4a4a4a" d="M2078.35,-413C1967.89,-409.18 1558.94,-395.41 1222,-389 1210.65,-388.78 413.48,-388.54 405,-381 337.87,-321.34 331.16,-247.34 390,-179.5 398.24,-170 434.61,-176.82 446,-171.5 459.55,-165.16 472.15,-154.35 481.87,-144.45"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="483.31,-145.97 485.91,-140.17 480.26,-143.08 483.31,-145.97"/>
 </g>
 <!-- docgen.cli.emit&#45;&gt;docgen.emitters.index -->
-<g id="edge32" class="edge imports">
+<g id="edge46" class="edge imports">
 <title>docgen.cli.emit&#45;&gt;docgen.emitters.index</title>
-<path fill="none" stroke="#4a4a4a" d="M826.34,-396.55C828.28,-391.63 830.07,-386.2 831.06,-381 842.69,-319.76 873.23,-146.41 831.06,-100.5 823.97,-92.78 747.41,-94.15 737.06,-92.5 676.52,-82.84 607.55,-65.3 565.68,-53.9"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="566.24,-51.88 559.9,-52.32 565.13,-55.93 566.24,-51.88"/>
+<path fill="none" stroke="#4a4a4a" d="M2078.35,-412.97C1967.89,-409.06 1558.95,-394.98 1222,-389 1214.36,-388.86 127.54,-386.26 122,-381 57,-319.32 79.87,-261.94 115,-179.5 160.01,-73.89 233.57,-91.38 344,-60 348.75,-58.65 353.71,-57.16 358.61,-55.65"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="359.18,-57.67 364.27,-53.87 357.92,-53.66 359.18,-57.67"/>
 </g>
 <!-- docgen.cli.emit&#45;&gt;docgen.emitters.minimap -->
-<g id="edge33" class="edge imports">
+<g id="edge47" class="edge imports">
 <title>docgen.cli.emit&#45;&gt;docgen.emitters.minimap</title>
-<path fill="none" stroke="#4a4a4a" d="M789.5,-413.82C685.09,-412.93 327.88,-407.94 285.06,-381 228.11,-345.17 125.64,-150.14 171.06,-100.5 184.62,-85.69 242.52,-100.2 261.06,-92.5 275.57,-86.48 289.2,-75.55 299.69,-65.5"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="301.02,-67.13 303.8,-61.41 298.06,-64.15 301.02,-67.13"/>
+<path fill="none" stroke="#4a4a4a" d="M2078.35,-412.97C1967.89,-409.04 1558.95,-394.93 1222,-389 1214.01,-388.86 77.63,-386.67 72,-381 -18.4,-289.97 15.77,-180.96 111,-95 145.7,-63.68 198.58,-51.19 236.93,-46.23"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="236.71,-48.38 242.41,-45.57 236.2,-44.21 236.71,-48.38"/>
 </g>
 <!-- docgen.cli.emit&#45;&gt;docgen.emitters.notebook -->
-<g id="edge34" class="edge imports">
+<g id="edge48" class="edge imports">
 <title>docgen.cli.emit&#45;&gt;docgen.emitters.notebook</title>
-<path fill="none" stroke="#4a4a4a" d="M789.72,-414.13C732.39,-413.78 605.51,-409.68 575.06,-381 510.77,-320.44 515.8,-203.08 521.55,-152.12"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="523.61,-152.52 522.25,-146.31 519.44,-152.02 523.61,-152.52"/>
+<path fill="none" stroke="#4a4a4a" d="M2078.35,-413.05C1967.88,-409.4 1558.93,-396.17 1222,-389 1206.5,-388.67 676.85,-389.67 664,-381 616.24,-348.77 600.98,-277.03 596.17,-239.1"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="598.29,-239.21 595.51,-233.49 594.12,-239.69 598.29,-239.21"/>
+</g>
+<!-- docgen.emitters.site -->
+<g id="docgen.emitters.site" class="node module">
+<title>docgen.emitters.site</title>
+<g id="a_docgen.emitters.site"><a xlink:href="emitters/site.py" xlink:title="IR &#45;&gt; a self&#45;contained documentation site: sidebar, content, graph viewer.">
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M416,-139C416,-139 386,-139 386,-139 380,-139 374,-133 374,-127 374,-127 374,-115 374,-115 374,-109 380,-103 386,-103 386,-103 416,-103 416,-103 422,-103 428,-109 428,-115 428,-115 428,-127 428,-127 428,-133 422,-139 416,-139"/>
+<text xml:space="preserve" text-anchor="middle" x="401" y="-117.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">site</text>
+</a>
+</g>
 </g>
 <!-- docgen.cli.emit&#45;&gt;docgen.emitters.site -->
-<g id="edge35" class="edge imports">
+<g id="edge49" class="edge imports">
 <title>docgen.cli.emit&#45;&gt;docgen.emitters.site</title>
-<path fill="none" stroke="#4a4a4a" d="M789.34,-414.6C722.02,-415.43 556.52,-413.96 514.06,-381 440.79,-324.11 424.03,-204.26 420.2,-152.35"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="422.3,-152.27 419.81,-146.42 418.11,-152.54 422.3,-152.27"/>
+<path fill="none" stroke="#4a4a4a" d="M2078.35,-413.13C1967.87,-409.78 1558.9,-397.52 1222,-389 1202.11,-388.5 883.05,-386.75 864,-381 770.86,-352.89 737.24,-341.93 679,-264 655.63,-232.73 685.69,-203.63 655,-179.5 636.73,-165.14 467.07,-181.31 446,-171.5 433.68,-165.76 423.22,-154.93 415.49,-144.85"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="417.39,-143.89 412.16,-140.28 413.99,-146.36 417.39,-143.89"/>
 </g>
 <!-- docgen.cli.emit&#45;&gt;docgen.notebook.spec -->
-<g id="edge36" class="edge imports">
+<g id="edge50" class="edge imports">
 <title>docgen.cli.emit&#45;&gt;docgen.notebook.spec</title>
-<path fill="none" stroke="#4a4a4a" d="M789.39,-413.97C678.26,-413.64 279.77,-410.4 232.06,-381 160.58,-336.95 120.54,-244.08 101.14,-183.81"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="103.25,-183.53 99.44,-178.44 99.24,-184.79 103.25,-183.53"/>
+<path fill="none" stroke="#4a4a4a" d="M2078.37,-413.21C1905.15,-408.46 1004.46,-383.59 998,-381 925.85,-352.08 907.28,-331.08 868,-264 852.89,-238.21 844.92,-205.94 840.7,-178.68"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="842.82,-178.63 839.88,-173 838.66,-179.24 842.82,-178.63"/>
 </g>
 <!-- docgen.cli.emit&#45;&gt;docgen.ops.filter -->
-<g id="edge37" class="edge imports">
+<g id="edge51" class="edge imports">
 <title>docgen.cli.emit&#45;&gt;docgen.ops.filter</title>
-<path fill="none" stroke="#4a4a4a" d="M846.72,-402.18C855.49,-397.04 864.12,-390.08 869.06,-381 898.85,-326.25 898.44,-155.48 869.06,-100.5 859.86,-83.27 842.95,-70.3 826.55,-61.08"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="827.67,-59.31 821.39,-58.32 825.69,-63.01 827.67,-59.31"/>
+<path fill="none" stroke="#4a4a4a" d="M2078.32,-414.03C1930.16,-414.04 1257.19,-412.35 1227,-381 1210.2,-363.55 1225.09,-296.15 1227,-272 1230.57,-226.91 1239.43,-216.59 1243,-171.5 1245.68,-137.61 1264.98,-120.94 1243,-95 1210.08,-56.14 1061.07,-46.29 981.48,-43.82"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="981.57,-41.72 975.51,-43.64 981.45,-45.92 981.57,-41.72"/>
 </g>
 <!-- docgen.cli.extract -->
 <g id="docgen.cli.extract" class="node module">
 <title>docgen.cli.extract</title>
 <g id="a_docgen.cli.extract"><a xlink:href="cli/extract.py" xlink:title="python3 &#45;m docgen extract python &#160;&#45;&#45;root SRC &#160;&#160;[&#45;o ir.json] [&#45;&#45;exclude NAME ...]">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1322.59,-433C1322.59,-433 1273.54,-433 1273.54,-433 1267.54,-433 1261.54,-427 1261.54,-421 1261.54,-421 1261.54,-409 1261.54,-409 1261.54,-403 1267.54,-397 1273.54,-397 1273.54,-397 1322.59,-397 1322.59,-397 1328.59,-397 1334.59,-403 1334.59,-409 1334.59,-409 1334.59,-421 1334.59,-421 1334.59,-427 1328.59,-433 1322.59,-433"/>
-<text xml:space="preserve" text-anchor="middle" x="1298.06" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">extract</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M2555.53,-433C2555.53,-433 2506.47,-433 2506.47,-433 2500.47,-433 2494.47,-427 2494.47,-421 2494.47,-421 2494.47,-409 2494.47,-409 2494.47,-403 2500.47,-397 2506.47,-397 2506.47,-397 2555.53,-397 2555.53,-397 2561.53,-397 2567.53,-403 2567.53,-409 2567.53,-409 2567.53,-421 2567.53,-421 2567.53,-427 2561.53,-433 2555.53,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="2531" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">extract</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.extract&#45;&gt;docgen.cli.common -->
-<g id="edge38" class="edge imports">
+<g id="edge52" class="edge imports">
 <title>docgen.cli.extract&#45;&gt;docgen.cli.common</title>
-<path fill="none" stroke="#4a4a4a" d="M1278.32,-396.53C1255.47,-376.32 1217.81,-343.01 1192.97,-321.03"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1194.59,-319.66 1188.7,-317.26 1191.8,-322.8 1194.59,-319.66"/>
-</g>
-<!-- docgen.extractors.code -->
-<g id="docgen.extractors.code" class="node module">
-<title>docgen.extractors.code</title>
-<g id="a_docgen.extractors.code"><a xlink:href="extractors/code.py" xlink:title="Source in several languages &#45;&gt; IR structure, via **tree&#45;sitter**.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1932.09,-316C1932.09,-316 1898.04,-316 1898.04,-316 1892.04,-316 1886.04,-310 1886.04,-304 1886.04,-304 1886.04,-292 1886.04,-292 1886.04,-286 1892.04,-280 1898.04,-280 1898.04,-280 1932.09,-280 1932.09,-280 1938.09,-280 1944.09,-286 1944.09,-292 1944.09,-292 1944.09,-304 1944.09,-304 1944.09,-310 1938.09,-316 1932.09,-316"/>
-<text xml:space="preserve" text-anchor="middle" x="1915.06" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">code</text>
-</a>
-</g>
+<path fill="none" stroke="#4a4a4a" d="M2505.33,-396.53C2475.34,-376.13 2425.72,-342.36 2393.45,-320.4"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2395.02,-318.93 2388.88,-317.29 2392.66,-322.4 2395.02,-318.93"/>
 </g>
 <!-- docgen.cli.extract&#45;&gt;docgen.extractors.code -->
-<g id="edge39" class="edge imports">
+<g id="edge53" class="edge imports">
 <title>docgen.cli.extract&#45;&gt;docgen.extractors.code</title>
-<path fill="none" stroke="#4a4a4a" d="M1330.12,-396.51C1337.16,-393.43 1344.71,-390.68 1352.06,-389 1380.01,-382.62 1843.37,-395.57 1868.06,-381 1889.12,-368.58 1901.58,-342.85 1908.33,-323.5"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1910.3,-324.24 1910.17,-317.88 1906.3,-322.93 1910.3,-324.24"/>
+<path fill="none" stroke="#4a4a4a" d="M2499.23,-396.62C2492.11,-393.49 2484.46,-390.69 2477,-389 2457.76,-384.65 1784.01,-390.98 1767,-381 1745.92,-368.63 1733.46,-342.89 1726.72,-323.53"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1728.74,-322.95 1724.89,-317.9 1724.75,-324.25 1728.74,-322.95"/>
 </g>
 <!-- docgen.extractors.db -->
 <g id="docgen.extractors.db" class="node module">
 <title>docgen.extractors.db</title>
 <g id="a_docgen.extractors.db"><a xlink:href="extractors/db.py" xlink:title="A database schema &#45;&gt; IR.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1724.06,-316C1724.06,-316 1694.06,-316 1694.06,-316 1688.06,-316 1682.06,-310 1682.06,-304 1682.06,-304 1682.06,-292 1682.06,-292 1682.06,-286 1688.06,-280 1694.06,-280 1694.06,-280 1724.06,-280 1724.06,-280 1730.06,-280 1736.06,-286 1736.06,-292 1736.06,-292 1736.06,-304 1736.06,-304 1736.06,-310 1730.06,-316 1724.06,-316"/>
-<text xml:space="preserve" text-anchor="middle" x="1709.06" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">db</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1929,-316C1929,-316 1899,-316 1899,-316 1893,-316 1887,-310 1887,-304 1887,-304 1887,-292 1887,-292 1887,-286 1893,-280 1899,-280 1899,-280 1929,-280 1929,-280 1935,-280 1941,-286 1941,-292 1941,-292 1941,-304 1941,-304 1941,-310 1935,-316 1929,-316"/>
+<text xml:space="preserve" text-anchor="middle" x="1914" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">db</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.extract&#45;&gt;docgen.extractors.db -->
-<g id="edge40" class="edge imports">
+<g id="edge54" class="edge imports">
 <title>docgen.cli.extract&#45;&gt;docgen.extractors.db</title>
-<path fill="none" stroke="#4a4a4a" d="M1330.14,-396.57C1337.17,-393.49 1344.72,-390.72 1352.06,-389 1369,-385.04 1650.25,-390.12 1665.06,-381 1685.56,-368.38 1697.1,-342.68 1703.17,-323.4"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1705.13,-324.16 1704.81,-317.81 1701.1,-322.98 1705.13,-324.16"/>
+<path fill="none" stroke="#4a4a4a" d="M2498.94,-396.51C2491.9,-393.43 2484.35,-390.68 2477,-389 2448.94,-382.59 1983.65,-395.85 1959,-381 1938.28,-368.52 1926.44,-342.8 1920.15,-323.47"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1922.21,-323 1918.45,-317.86 1918.19,-324.22 1922.21,-323"/>
 </g>
 <!-- docgen.extractors.openapi -->
 <g id="docgen.extractors.openapi" class="node module">
 <title>docgen.extractors.openapi</title>
 <g id="a_docgen.extractors.openapi"><a xlink:href="extractors/openapi.py" xlink:title="An OpenAPI document &#45;&gt; IR: the endpoints, and the shapes they carry.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1837.84,-316C1837.84,-316 1784.29,-316 1784.29,-316 1778.29,-316 1772.29,-310 1772.29,-304 1772.29,-304 1772.29,-292 1772.29,-292 1772.29,-286 1778.29,-280 1784.29,-280 1784.29,-280 1837.84,-280 1837.84,-280 1843.84,-280 1849.84,-286 1849.84,-292 1849.84,-292 1849.84,-304 1849.84,-304 1849.84,-310 1843.84,-316 1837.84,-316"/>
-<text xml:space="preserve" text-anchor="middle" x="1811.06" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">openapi</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M2042.78,-316C2042.78,-316 1989.22,-316 1989.22,-316 1983.22,-316 1977.22,-310 1977.22,-304 1977.22,-304 1977.22,-292 1977.22,-292 1977.22,-286 1983.22,-280 1989.22,-280 1989.22,-280 2042.78,-280 2042.78,-280 2048.78,-280 2054.78,-286 2054.78,-292 2054.78,-292 2054.78,-304 2054.78,-304 2054.78,-310 2048.78,-316 2042.78,-316"/>
+<text xml:space="preserve" text-anchor="middle" x="2016" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">openapi</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.extract&#45;&gt;docgen.extractors.openapi -->
-<g id="edge41" class="edge imports">
+<g id="edge55" class="edge imports">
 <title>docgen.cli.extract&#45;&gt;docgen.extractors.openapi</title>
-<path fill="none" stroke="#4a4a4a" d="M1330.13,-396.54C1337.17,-393.46 1344.71,-390.7 1352.06,-389 1373.83,-383.98 1734.37,-391.54 1754.06,-381 1777.07,-368.68 1792.73,-342.5 1801.72,-323.02"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1803.63,-323.9 1804.13,-317.57 1799.78,-322.21 1803.63,-323.9"/>
+<path fill="none" stroke="#4a4a4a" d="M2498.93,-396.53C2491.9,-393.45 2484.35,-390.69 2477,-389 2454.53,-383.82 2081.79,-392.84 2062,-381 2041.14,-368.51 2028.98,-342.79 2022.46,-323.47"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2024.5,-322.94 2020.69,-317.86 2020.49,-324.21 2024.5,-322.94"/>
 </g>
 <!-- docgen.extractors.python.collect -->
 <g id="docgen.extractors.python.collect" class="node module">
 <title>docgen.extractors.python.collect</title>
 <g id="a_docgen.extractors.python.collect"><a xlink:href="extractors/python/collect.py" xlink:title="Pass one: read each module, record what it defines and what it imports.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1634.09,-316C1634.09,-316 1588.04,-316 1588.04,-316 1582.04,-316 1576.04,-310 1576.04,-304 1576.04,-304 1576.04,-292 1576.04,-292 1576.04,-286 1582.04,-280 1588.04,-280 1588.04,-280 1634.09,-280 1634.09,-280 1640.09,-280 1646.09,-286 1646.09,-292 1646.09,-292 1646.09,-304 1646.09,-304 1646.09,-310 1640.09,-316 1634.09,-316"/>
-<text xml:space="preserve" text-anchor="middle" x="1611.06" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">collect</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1643.03,-316C1643.03,-316 1596.97,-316 1596.97,-316 1590.97,-316 1584.97,-310 1584.97,-304 1584.97,-304 1584.97,-292 1584.97,-292 1584.97,-286 1590.97,-280 1596.97,-280 1596.97,-280 1643.03,-280 1643.03,-280 1649.03,-280 1655.03,-286 1655.03,-292 1655.03,-292 1655.03,-304 1655.03,-304 1655.03,-310 1649.03,-316 1643.03,-316"/>
+<text xml:space="preserve" text-anchor="middle" x="1620" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">collect</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.extract&#45;&gt;docgen.extractors.python.collect -->
-<g id="edge42" class="edge imports">
+<g id="edge56" class="edge imports">
 <title>docgen.cli.extract&#45;&gt;docgen.extractors.python.collect</title>
-<path fill="none" stroke="#4a4a4a" d="M1330.44,-396.5C1337.39,-393.47 1344.83,-390.73 1352.06,-389 1375.85,-383.31 1551.62,-394.44 1572.06,-381 1581.73,-374.65 1589.05,-365.2 1594.59,-354.96"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1596.34,-356.16 1597.14,-349.85 1592.58,-354.28 1596.34,-356.16"/>
+<path fill="none" stroke="#4a4a4a" d="M2499.24,-396.61C2492.12,-393.48 2484.46,-390.68 2477,-389 2454.83,-384 1678.15,-393.23 1659,-381 1649.2,-374.74 1641.81,-365.29 1636.26,-354.99"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1638.25,-354.29 1633.7,-349.85 1634.49,-356.16 1638.25,-354.29"/>
 </g>
 <!-- docgen.extractors.usage -->
 <g id="docgen.extractors.usage" class="node module">
 <title>docgen.extractors.usage</title>
 <g id="a_docgen.extractors.usage"><a xlink:href="extractors/usage.py" xlink:title="Recorded traffic &#45;&gt; IR. What callers actually do, rather than what exists.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1527.84,-316C1527.84,-316 1486.29,-316 1486.29,-316 1480.29,-316 1474.29,-310 1474.29,-304 1474.29,-304 1474.29,-292 1474.29,-292 1474.29,-286 1480.29,-280 1486.29,-280 1486.29,-280 1527.84,-280 1527.84,-280 1533.84,-280 1539.84,-286 1539.84,-292 1539.84,-292 1539.84,-304 1539.84,-304 1539.84,-310 1533.84,-316 1527.84,-316"/>
-<text xml:space="preserve" text-anchor="middle" x="1507.06" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">usage</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1838.78,-316C1838.78,-316 1797.22,-316 1797.22,-316 1791.22,-316 1785.22,-310 1785.22,-304 1785.22,-304 1785.22,-292 1785.22,-292 1785.22,-286 1791.22,-280 1797.22,-280 1797.22,-280 1838.78,-280 1838.78,-280 1844.78,-280 1850.78,-286 1850.78,-292 1850.78,-292 1850.78,-304 1850.78,-304 1850.78,-310 1844.78,-316 1838.78,-316"/>
+<text xml:space="preserve" text-anchor="middle" x="1818" y="-294.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">usage</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.extract&#45;&gt;docgen.extractors.usage -->
-<g id="edge43" class="edge imports">
+<g id="edge57" class="edge imports">
 <title>docgen.cli.extract&#45;&gt;docgen.extractors.usage</title>
-<path fill="none" stroke="#4a4a4a" d="M1330.78,-396.56C1337.64,-393.56 1344.96,-390.83 1352.06,-389 1376.87,-382.62 1445.82,-395.32 1467.06,-381 1486.42,-367.95 1496.75,-342.73 1502.03,-323.69"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1504.05,-324.28 1503.5,-317.95 1499.98,-323.24 1504.05,-324.28"/>
+<path fill="none" stroke="#4a4a4a" d="M2498.94,-396.5C2491.91,-393.42 2484.35,-390.67 2477,-389 2444.06,-381.52 1898.42,-397.6 1869,-381 1847.15,-368.67 1833.42,-342.74 1825.78,-323.32"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1827.83,-322.81 1823.77,-317.92 1823.9,-324.27 1827.83,-322.81"/>
 </g>
 <!-- docgen.cli.run -->
 <g id="docgen.cli.run" class="node module">
 <title>docgen.cli.run</title>
 <g id="a_docgen.cli.run"><a xlink:href="cli/run.py" xlink:title="python3 &#45;m docgen run [docgen.toml] [&#45;&#45;only NAME ...] [&#45;&#45;check] [&#45;&#45;list]">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M924.06,-433C924.06,-433 894.06,-433 894.06,-433 888.06,-433 882.06,-427 882.06,-421 882.06,-421 882.06,-409 882.06,-409 882.06,-403 888.06,-397 894.06,-397 894.06,-397 924.06,-397 924.06,-397 930.06,-397 936.06,-403 936.06,-409 936.06,-409 936.06,-421 936.06,-421 936.06,-427 930.06,-433 924.06,-433"/>
-<text xml:space="preserve" text-anchor="middle" x="909.06" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">run</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M2762,-433C2762,-433 2732,-433 2732,-433 2726,-433 2720,-427 2720,-421 2720,-421 2720,-409 2720,-409 2720,-403 2726,-397 2732,-397 2732,-397 2762,-397 2762,-397 2768,-397 2774,-403 2774,-409 2774,-409 2774,-421 2774,-421 2774,-427 2768,-433 2762,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="2747" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">run</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.run&#45;&gt;docgen.book.config -->
-<g id="edge44" class="edge imports">
+<g id="edge58" class="edge imports">
 <title>docgen.cli.run&#45;&gt;docgen.book.config</title>
-<path fill="none" stroke="#4a4a4a" d="M882.34,-396.53C876.52,-393.49 870.26,-390.75 864.06,-389 843.94,-383.33 694.12,-391.54 676.06,-381 654.4,-368.35 640.64,-342.48 632.94,-323.16"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="635,-322.66 630.91,-317.79 631.07,-324.14 635,-322.66"/>
+<path fill="none" stroke="#4a4a4a" d="M2742.66,-433.32C2735.47,-458.76 2718.36,-503.46 2684,-519.5 2623.19,-547.9 2147,-523.34 2080,-519.5 1742.97,-500.19 1339.08,-440.93 1211.6,-421.35"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1212.06,-419.3 1205.81,-420.46 1211.42,-423.45 1212.06,-419.3"/>
 </g>
 <!-- docgen.cli.run&#45;&gt;docgen.cli.common -->
-<g id="edge45" class="edge imports">
+<g id="edge59" class="edge imports">
 <title>docgen.cli.run&#45;&gt;docgen.cli.common</title>
-<path fill="none" stroke="#4a4a4a" d="M936.42,-398.18C942.18,-395.02 948.28,-391.81 954.06,-389 1010.32,-361.65 1077.01,-334.38 1120.82,-317.15"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1121.42,-319.17 1126.24,-315.02 1119.88,-315.26 1121.42,-319.17"/>
+<path fill="none" stroke="#4a4a4a" d="M2719.93,-397.55C2714.14,-394.43 2707.97,-391.4 2702,-389 2601.31,-348.44 2476.51,-320.81 2409.64,-307.71"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2410.34,-305.71 2404.05,-306.63 2409.54,-309.83 2410.34,-305.71"/>
+</g>
+<!-- docgen.cli.scaffold -->
+<g id="docgen.cli.scaffold" class="node module">
+<title>docgen.cli.scaffold</title>
+<g id="a_docgen.cli.scaffold"><a xlink:href="cli/scaffold.py" xlink:title="python3 &#45;m docgen scaffold &lt;docgen.toml&gt; [&#45;&#45;only NAME ...]">
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M2331.78,-433C2331.78,-433 2278.22,-433 2278.22,-433 2272.22,-433 2266.22,-427 2266.22,-421 2266.22,-421 2266.22,-409 2266.22,-409 2266.22,-403 2272.22,-397 2278.22,-397 2278.22,-397 2331.78,-397 2331.78,-397 2337.78,-397 2343.78,-403 2343.78,-409 2343.78,-409 2343.78,-421 2343.78,-421 2343.78,-427 2337.78,-433 2331.78,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="2305" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">scaffold</text>
+</a>
+</g>
+</g>
+<!-- docgen.cli.scaffold&#45;&gt;docgen.book.config -->
+<g id="edge60" class="edge imports">
+<title>docgen.cli.scaffold&#45;&gt;docgen.book.config</title>
+<path fill="none" stroke="#4a4a4a" d="M2298.56,-433.08C2288.46,-458.23 2266.22,-502.59 2230,-519.5 2169.6,-547.71 2146.56,-523.31 2080,-519.5 1742.97,-500.19 1339.08,-440.93 1211.6,-421.35"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1212.06,-419.3 1205.81,-420.46 1211.42,-423.45 1212.06,-419.3"/>
+</g>
+<!-- docgen.cli.scaffold&#45;&gt;docgen.book.document -->
+<g id="edge61" class="edge imports">
+<title>docgen.cli.scaffold&#45;&gt;docgen.book.document</title>
+<path fill="none" stroke="#4a4a4a" d="M2271.39,-396.61C2263.88,-393.48 2255.82,-390.68 2248,-389 2226.11,-384.3 1461.05,-392.76 1442,-381 1395.66,-352.39 1431.95,-301.23 1386,-272 1365.74,-259.11 1193.38,-269.47 1170,-264 1144.42,-258.01 1117.51,-246.01 1096.7,-235.32"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1097.8,-233.53 1091.51,-232.61 1095.85,-237.25 1097.8,-233.53"/>
+</g>
+<!-- docgen.cli.scaffold&#45;&gt;docgen.book.notes -->
+<g id="edge62" class="edge imports">
+<title>docgen.cli.scaffold&#45;&gt;docgen.book.notes</title>
+<path fill="none" stroke="#4a4a4a" d="M2271.39,-396.61C2263.88,-393.48 2255.82,-390.68 2248,-389 2227.14,-384.51 1498.15,-392.21 1480,-381 1433.66,-352.38 1469.99,-301.18 1424,-272 1402.22,-258.18 1215.11,-275.46 1192,-264 1148.56,-242.46 1154.43,-216.42 1123,-179.5 1113.22,-168.01 1102.13,-155.46 1092.8,-145.02"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1094.39,-143.65 1088.82,-140.58 1091.26,-146.45 1094.39,-143.65"/>
+</g>
+<!-- docgen.cli.scaffold&#45;&gt;docgen.cli.common -->
+<g id="edge63" class="edge imports">
+<title>docgen.cli.scaffold&#45;&gt;docgen.cli.common</title>
+<path fill="none" stroke="#4a4a4a" d="M2313.66,-396.53C2323.42,-376.83 2339.36,-344.68 2350.24,-322.72"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2351.99,-323.92 2352.78,-317.61 2348.23,-322.05 2351.99,-323.92"/>
 </g>
 <!-- docgen.cli.validate -->
 <g id="docgen.cli.validate" class="node module">
 <title>docgen.cli.validate</title>
 <g id="a_docgen.cli.validate"><a xlink:href="cli/validate.py" xlink:title="python3 &#45;m docgen validate &lt;ir.json&gt;">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1437.59,-433C1437.59,-433 1382.54,-433 1382.54,-433 1376.54,-433 1370.54,-427 1370.54,-421 1370.54,-421 1370.54,-409 1370.54,-409 1370.54,-403 1376.54,-397 1382.54,-397 1382.54,-397 1437.59,-397 1437.59,-397 1443.59,-397 1449.59,-403 1449.59,-409 1449.59,-409 1449.59,-421 1449.59,-421 1449.59,-427 1443.59,-433 1437.59,-433"/>
-<text xml:space="preserve" text-anchor="middle" x="1410.06" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">validate</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M2446.53,-433C2446.53,-433 2391.47,-433 2391.47,-433 2385.47,-433 2379.47,-427 2379.47,-421 2379.47,-421 2379.47,-409 2379.47,-409 2379.47,-403 2385.47,-397 2391.47,-397 2391.47,-397 2446.53,-397 2446.53,-397 2452.53,-397 2458.53,-403 2458.53,-409 2458.53,-409 2458.53,-421 2458.53,-421 2458.53,-427 2452.53,-433 2446.53,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="2419" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">validate</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.validate&#45;&gt;docgen.cli.common -->
-<g id="edge46" class="edge imports">
+<g id="edge64" class="edge imports">
 <title>docgen.cli.validate&#45;&gt;docgen.cli.common</title>
-<path fill="none" stroke="#4a4a4a" d="M1373.31,-396.53C1329.83,-375.87 1257.54,-341.52 1211.38,-319.58"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1212.45,-317.77 1206.13,-317.09 1210.65,-321.56 1212.45,-317.77"/>
+<path fill="none" stroke="#4a4a4a" d="M2410.34,-396.53C2400.58,-376.83 2384.64,-344.68 2373.76,-322.72"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2375.77,-322.05 2371.22,-317.61 2372.01,-323.92 2375.77,-322.05"/>
 </g>
 <!-- docgen.ir.validate -->
 <g id="docgen.ir.validate" class="node module">
 <title>docgen.ir.validate</title>
 <g id="a_docgen.ir.validate"><a xlink:href="ir/validate.py" xlink:title="Check an IR document at the boundary.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1750.59,-60C1750.59,-60 1695.54,-60 1695.54,-60 1689.54,-60 1683.54,-54 1683.54,-48 1683.54,-48 1683.54,-36 1683.54,-36 1683.54,-30 1689.54,-24 1695.54,-24 1695.54,-24 1750.59,-24 1750.59,-24 1756.59,-24 1762.59,-30 1762.59,-36 1762.59,-36 1762.59,-48 1762.59,-48 1762.59,-54 1756.59,-60 1750.59,-60"/>
-<text xml:space="preserve" text-anchor="middle" x="1723.06" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">validate</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1845.53,-60C1845.53,-60 1790.47,-60 1790.47,-60 1784.47,-60 1778.47,-54 1778.47,-48 1778.47,-48 1778.47,-36 1778.47,-36 1778.47,-30 1784.47,-24 1790.47,-24 1790.47,-24 1845.53,-24 1845.53,-24 1851.53,-24 1857.53,-30 1857.53,-36 1857.53,-36 1857.53,-48 1857.53,-48 1857.53,-54 1851.53,-60 1845.53,-60"/>
+<text xml:space="preserve" text-anchor="middle" x="1818" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">validate</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.validate&#45;&gt;docgen.ir.validate -->
-<g id="edge47" class="edge imports">
+<g id="edge65" class="edge imports">
 <title>docgen.cli.validate&#45;&gt;docgen.ir.validate</title>
-<path fill="none" stroke="#4a4a4a" d="M1450,-403.11C1471.47,-397.78 1498.52,-391.89 1523.06,-389 1536.03,-387.47 1983.91,-390.31 1993.06,-381 2054.17,-318.84 2033.69,-258.01 1986.06,-185 1936.34,-108.78 1831.32,-70.35 1770.1,-53.7"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1770.66,-51.68 1764.32,-52.17 1769.58,-55.74 1770.66,-51.68"/>
+<path fill="none" stroke="#4a4a4a" d="M2385.39,-396.61C2377.88,-393.48 2369.82,-390.68 2362,-389 2351.22,-386.68 1575.76,-388.84 1568,-381 1504.99,-317.36 1522.3,-256.52 1568,-179.5 1612.01,-105.33 1712.09,-68.86 1771.42,-53.15"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1771.69,-55.25 1776.98,-51.72 1770.64,-51.19 1771.69,-55.25"/>
 </g>
 <!-- docgen.cli.view -->
 <g id="docgen.cli.view" class="node module">
 <title>docgen.cli.view</title>
 <g id="a_docgen.cli.view"><a xlink:href="cli/view.py" xlink:title="python3 &#45;m docgen view &lt;ir.json&gt; [views...] [&#45;o out.json]">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1213.09,-433C1213.09,-433 1179.04,-433 1179.04,-433 1173.04,-433 1167.04,-427 1167.04,-421 1167.04,-421 1167.04,-409 1167.04,-409 1167.04,-403 1173.04,-397 1179.04,-397 1179.04,-397 1213.09,-397 1213.09,-397 1219.09,-397 1225.09,-403 1225.09,-409 1225.09,-409 1225.09,-421 1225.09,-421 1225.09,-427 1219.09,-433 1213.09,-433"/>
-<text xml:space="preserve" text-anchor="middle" x="1196.06" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">view</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M2956.03,-433C2956.03,-433 2921.97,-433 2921.97,-433 2915.97,-433 2909.97,-427 2909.97,-421 2909.97,-421 2909.97,-409 2909.97,-409 2909.97,-403 2915.97,-397 2921.97,-397 2921.97,-397 2956.03,-397 2956.03,-397 2962.03,-397 2968.03,-403 2968.03,-409 2968.03,-409 2968.03,-421 2968.03,-421 2968.03,-427 2962.03,-433 2956.03,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="2939" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">view</text>
 </a>
 </g>
 </g>
 <!-- docgen.cli.view&#45;&gt;docgen.cli.common -->
-<g id="edge48" class="edge imports">
+<g id="edge66" class="edge imports">
 <title>docgen.cli.view&#45;&gt;docgen.cli.common</title>
-<path fill="none" stroke="#4a4a4a" d="M1191.81,-396.53C1187.05,-377 1179.32,-345.23 1173.98,-323.29"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1176.08,-323.06 1172.62,-317.72 1172,-324.05 1176.08,-323.06"/>
+<path fill="none" stroke="#4a4a4a" d="M2911.01,-396.53C2904.95,-393.49 2898.42,-390.75 2892,-389 2852.3,-378.18 2747.76,-386.67 2707,-381 2599.19,-366 2475.73,-332.6 2409.67,-313.38"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2410.48,-311.43 2404.13,-311.76 2409.3,-315.46 2410.48,-311.43"/>
 </g>
 <!-- docgen.cli.view&#45;&gt;docgen.ir.model -->
-<g id="edge49" class="edge imports">
+<g id="edge67" class="edge imports">
 <title>docgen.cli.view&#45;&gt;docgen.ir.model</title>
-<path fill="none" stroke="#4a4a4a" d="M1223.5,-396.62C1229.71,-393.49 1236.44,-390.69 1243.06,-389 1262.39,-384.07 1947.04,-395.18 1961.06,-381 2022.32,-319.06 2014.94,-253.45 1961.06,-185 1938.73,-156.63 1841.26,-140.6 1778.19,-133.02"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1778.77,-130.97 1772.56,-132.35 1778.28,-135.14 1778.77,-130.97"/>
+<path fill="none" stroke="#4a4a4a" d="M2909.59,-397.21C2903.86,-394.27 2897.81,-391.38 2892,-389 2590.36,-265.28 2507.04,-251.19 2189,-179.5 2078.13,-154.51 1946.18,-136.89 1873.29,-128.19"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1873.71,-126.12 1867.5,-127.5 1873.21,-130.29 1873.71,-126.12"/>
 </g>
 <!-- docgen.cli.view&#45;&gt;docgen.ops.filter -->
-<g id="edge50" class="edge imports">
+<g id="edge68" class="edge imports">
 <title>docgen.cli.view&#45;&gt;docgen.ops.filter</title>
-<path fill="none" stroke="#4a4a4a" d="M1166.56,-396.67C1160.88,-393.81 1154.89,-391.1 1149.06,-389 1132.41,-383.01 1122.9,-393.18 1110.06,-381 1044.77,-319.04 1115.32,-255.27 1059.06,-185 999.01,-109.99 888.72,-70.58 827.3,-53.57"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="827.86,-51.55 821.52,-52 826.76,-55.6 827.86,-51.55"/>
+<path fill="none" stroke="#4a4a4a" d="M2911.57,-396.59C2905.36,-393.46 2898.63,-390.67 2892,-389 2840.98,-376.16 1047.08,-399.95 998,-381 873.84,-333.05 831.96,-295.66 784,-171.5 771.75,-139.78 764.37,-122.76 784,-95 806.67,-62.93 850.87,-50.51 884.9,-45.76"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="884.81,-47.89 890.5,-45.05 884.28,-43.73 884.81,-47.89"/>
 </g>
 <!-- docgen.emitters.auto&#45;&gt;docgen.emitters.dot -->
-<g id="edge51" class="edge imports">
+<g id="edge69" class="edge imports">
 <title>docgen.emitters.auto&#45;&gt;docgen.emitters.dot</title>
-<path fill="none" stroke="#4a4a4a" d="M299.48,-109.66C293.46,-106.51 287.1,-103.3 281.06,-100.5 272.38,-96.47 268.93,-97.96 261.06,-92.5 250.63,-85.26 240.91,-75.18 233.18,-66"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="235.02,-64.93 229.6,-61.61 231.77,-67.59 235.02,-64.93"/>
+<path fill="none" stroke="#4a4a4a" d="M602.32,-102.53C601.92,-92.29 601.41,-79.19 600.97,-67.88"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="603.07,-67.83 600.74,-61.92 598.87,-67.99 603.07,-67.83"/>
 </g>
 <!-- docgen.emitters.auto&#45;&gt;docgen.emitters.erd -->
-<g id="edge52" class="edge imports">
+<g id="edge70" class="edge imports">
 <title>docgen.emitters.auto&#45;&gt;docgen.emitters.erd</title>
-<path fill="none" stroke="#4a4a4a" d="M356.78,-108.76C364.31,-103.89 372.23,-98.3 379.06,-92.5 388.51,-84.49 397.89,-74.56 405.63,-65.7"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="407.16,-67.14 409.47,-61.22 403.97,-64.41 407.16,-67.14"/>
+<path fill="none" stroke="#4a4a4a" d="M580.54,-102.53C566.23,-91.4 547.58,-76.9 532.28,-64.99"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="533.6,-63.36 527.57,-61.33 531.02,-66.67 533.6,-63.36"/>
 </g>
 <!-- docgen.emitters.auto&#45;&gt;docgen.emitters.index -->
-<g id="edge53" class="edge imports">
+<g id="edge71" class="edge imports">
 <title>docgen.emitters.auto&#45;&gt;docgen.emitters.index</title>
-<path fill="none" stroke="#4a4a4a" d="M355.48,-108.23C361.41,-105.18 367.79,-102.38 374.06,-100.5 414.65,-88.35 429.96,-108.81 469.06,-92.5 483.42,-86.51 496.82,-75.59 507.11,-65.53"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="508.42,-67.19 511.14,-61.45 505.43,-64.24 508.42,-67.19"/>
+<path fill="none" stroke="#4a4a4a" d="M574.3,-103.73C568.34,-100.64 562.04,-97.57 556,-95 515.88,-77.92 468.13,-62.99 435.49,-53.56"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="436.16,-51.57 429.82,-51.93 435.01,-55.6 436.16,-51.57"/>
 </g>
 <!-- docgen.emitters.auto&#45;&gt;docgen.ops.filter -->
-<g id="edge54" class="edge imports">
+<g id="edge72" class="edge imports">
 <title>docgen.emitters.auto&#45;&gt;docgen.ops.filter</title>
-<path fill="none" stroke="#4a4a4a" d="M355.41,-108C361.35,-104.97 367.75,-102.23 374.06,-100.5 419.31,-88.08 538.61,-99.11 585.06,-92.5 638.79,-84.85 699.09,-68.64 738.88,-56.84"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="739.47,-58.86 744.61,-55.13 738.26,-54.84 739.47,-58.86"/>
+<path fill="none" stroke="#4a4a4a" d="M631.56,-102.69C637.2,-99.79 643.17,-97.06 649,-95 729.1,-66.66 827.75,-52.99 884.6,-47.03"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="884.74,-49.13 890.5,-46.43 884.31,-44.95 884.74,-49.13"/>
+</g>
+<!-- docgen.emitters.docsite -->
+<g id="docgen.emitters.docsite" class="node module">
+<title>docgen.emitters.docsite</title>
+<g id="a_docgen.emitters.docsite"><a xlink:href="emitters/docsite.py" xlink:title="A document&#39;s site: an index of books, and every book as pages you click through.">
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M502.9,-231.5C502.9,-231.5 453.1,-231.5 453.1,-231.5 447.1,-231.5 441.1,-225.5 441.1,-219.5 441.1,-219.5 441.1,-207.5 441.1,-207.5 441.1,-201.5 447.1,-195.5 453.1,-195.5 453.1,-195.5 502.9,-195.5 502.9,-195.5 508.9,-195.5 514.9,-201.5 514.9,-207.5 514.9,-207.5 514.9,-219.5 514.9,-219.5 514.9,-225.5 508.9,-231.5 502.9,-231.5"/>
+<text xml:space="preserve" text-anchor="middle" x="478" y="-209.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">docsite</text>
+</a>
+</g>
+</g>
+<!-- docgen.emitters.docsite&#45;&gt;docgen.book.document -->
+<g id="edge73" class="edge imports">
+<title>docgen.emitters.docsite&#45;&gt;docgen.book.document</title>
+<path fill="none" stroke="#4a4a4a" d="M493.53,-232C503.68,-242.91 517.83,-256.09 533,-264 540.27,-267.79 542.85,-267.11 551,-268 597.28,-273.08 923.72,-273.08 970,-268 978.15,-267.11 980.5,-267.31 988,-264 1003.99,-256.95 1020.08,-246.11 1032.98,-236.28"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1034.03,-238.12 1037.47,-232.77 1031.45,-234.8 1034.03,-238.12"/>
+</g>
+<!-- docgen.emitters.markdown -->
+<g id="docgen.emitters.markdown" class="node module">
+<title>docgen.emitters.markdown</title>
+<g id="a_docgen.emitters.markdown"><a xlink:href="emitters/markdown.py" xlink:title="Markdown &#45;&gt; HTML, for notes on the site. Stdlib only, and deliberately small.">
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M325.65,-139C325.65,-139 256.35,-139 256.35,-139 250.35,-139 244.35,-133 244.35,-127 244.35,-127 244.35,-115 244.35,-115 244.35,-109 250.35,-103 256.35,-103 256.35,-103 325.65,-103 325.65,-103 331.65,-103 337.65,-109 337.65,-115 337.65,-115 337.65,-127 337.65,-127 337.65,-133 331.65,-139 325.65,-139"/>
+<text xml:space="preserve" text-anchor="middle" x="291" y="-117.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">markdown</text>
+</a>
+</g>
+</g>
+<!-- docgen.emitters.docsite&#45;&gt;docgen.emitters.markdown -->
+<g id="edge74" class="edge imports">
+<title>docgen.emitters.docsite&#45;&gt;docgen.emitters.markdown</title>
+<path fill="none" stroke="#4a4a4a" d="M449.26,-195.05C438.54,-189.25 426.04,-183.31 414,-179.5 389.19,-171.65 380.03,-181.49 356,-171.5 340.58,-165.09 325.59,-154.11 313.91,-144.11"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="315.47,-142.69 309.58,-140.31 312.7,-145.85 315.47,-142.69"/>
+</g>
+<!-- docgen.emitters.docsite&#45;&gt;docgen.emitters.paged -->
+<g id="edge75" class="edge imports">
+<title>docgen.emitters.docsite&#45;&gt;docgen.emitters.paged</title>
+<path fill="none" stroke="#4a4a4a" d="M501.46,-195.09C510.8,-189.07 521.95,-182.97 533,-179.5 557.65,-171.75 625.4,-182.03 649,-171.5 662.12,-165.65 673.86,-154.88 682.75,-144.87"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="684.12,-146.51 686.41,-140.58 680.92,-143.79 684.12,-146.51"/>
+</g>
+<!-- docgen.emitters.docsite&#45;&gt;docgen.emitters.site -->
+<g id="edge76" class="edge imports">
+<title>docgen.emitters.docsite&#45;&gt;docgen.emitters.site</title>
+<path fill="none" stroke="#4a4a4a" d="M463.15,-195.05C451.01,-180.78 433.74,-160.48 420.49,-144.9"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="422.27,-143.76 416.78,-140.55 419.07,-146.48 422.27,-143.76"/>
 </g>
 <!-- docgen.emitters.explore&#45;&gt;docgen.emitters.dot -->
-<g id="edge55" class="edge imports">
+<g id="edge77" class="edge imports">
 <title>docgen.emitters.explore&#45;&gt;docgen.emitters.dot</title>
-<path fill="none" stroke="#4a4a4a" d="M223.94,-108C222.52,-96.3 220.64,-80.73 219.06,-67.76"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="221.17,-67.68 218.36,-61.97 217,-68.18 221.17,-67.68"/>
+<path fill="none" stroke="#4a4a4a" d="M523.46,-102.53C537.77,-91.4 556.42,-76.9 571.72,-64.99"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="572.98,-66.67 576.43,-61.33 570.4,-63.36 572.98,-66.67"/>
 </g>
 <!-- docgen.emitters.explore&#45;&gt;docgen.emitters.erd -->
-<g id="edge56" class="edge imports">
+<g id="edge78" class="edge imports">
 <title>docgen.emitters.explore&#45;&gt;docgen.emitters.erd</title>
-<path fill="none" stroke="#4a4a4a" d="M260.36,-108.02C267.38,-105.06 274.84,-102.35 282.06,-100.5 303.01,-95.13 359.66,-102.06 379.06,-92.5 390.97,-86.64 401.21,-76.14 408.91,-66.32"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="410.56,-67.62 412.45,-61.56 407.19,-65.11 410.56,-67.62"/>
+<path fill="none" stroke="#4a4a4a" d="M501.68,-102.53C502.08,-92.29 502.59,-79.19 503.03,-67.88"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="505.13,-67.99 503.26,-61.92 500.93,-67.83 505.13,-67.99"/>
 </g>
 <!-- docgen.emitters.explore&#45;&gt;docgen.emitters.minimap -->
-<g id="edge57" class="edge imports">
+<g id="edge79" class="edge imports">
 <title>docgen.emitters.explore&#45;&gt;docgen.emitters.minimap</title>
-<path fill="none" stroke="#4a4a4a" d="M246,-108C260.2,-95.53 279.42,-78.67 294.71,-65.25"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="295.89,-67.01 299.02,-61.47 293.12,-63.85 295.89,-67.01"/>
+<path fill="none" stroke="#4a4a4a" d="M464.27,-102.6C458.21,-99.94 451.97,-97.31 446,-95 408.69,-80.55 365.51,-66.76 333.27,-57.01"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="333.94,-55.02 327.59,-55.31 332.74,-59.05 333.94,-55.02"/>
 </g>
 <!-- docgen.emitters.explore&#45;&gt;docgen.ops.filter -->
-<g id="edge58" class="edge imports">
+<g id="edge80" class="edge imports">
 <title>docgen.emitters.explore&#45;&gt;docgen.ops.filter</title>
-<path fill="none" stroke="#4a4a4a" d="M259.38,-108.08C266.67,-104.99 274.48,-102.22 282.06,-100.5 347.75,-85.59 518.32,-101.61 585.06,-92.5 638.82,-85.16 699.11,-68.89 738.88,-57"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="739.48,-59.01 744.62,-55.27 738.27,-54.99 739.48,-59.01"/>
+<path fill="none" stroke="#4a4a4a" d="M535.98,-102.58C542.83,-99.69 550.04,-96.99 557,-95 617.69,-77.61 798.78,-56.95 884.74,-47.79"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="884.75,-49.9 890.5,-47.17 884.31,-45.72 884.75,-49.9"/>
+</g>
+<!-- docgen.emitters.paged&#45;&gt;docgen.emitters.dot -->
+<g id="edge81" class="edge imports">
+<title>docgen.emitters.paged&#45;&gt;docgen.emitters.dot</title>
+<path fill="none" stroke="#4a4a4a" d="M677.31,-102.53C662.73,-91.3 643.69,-76.64 628.15,-64.68"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="629.84,-63.32 623.8,-61.33 627.27,-66.65 629.84,-63.32"/>
+</g>
+<!-- docgen.emitters.paged&#45;&gt;docgen.emitters.erd -->
+<g id="edge82" class="edge imports">
+<title>docgen.emitters.paged&#45;&gt;docgen.emitters.erd</title>
+<path fill="none" stroke="#4a4a4a" d="M666.5,-102.92C660.72,-100.16 654.72,-97.42 649,-95 628.68,-86.41 574.32,-67.29 538.24,-54.78"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="539.07,-52.85 532.71,-52.87 537.69,-56.82 539.07,-52.85"/>
+</g>
+<!-- docgen.emitters.paged&#45;&gt;docgen.ops.filter -->
+<g id="edge83" class="edge imports">
+<title>docgen.emitters.paged&#45;&gt;docgen.ops.filter</title>
+<path fill="none" stroke="#4a4a4a" d="M733.41,-105.39C742.01,-101.82 751.29,-98.13 760,-95 801.74,-80 850.18,-65.54 884.83,-55.69"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="885.35,-57.73 890.55,-54.07 884.2,-53.68 885.35,-57.73"/>
 </g>
 <!-- docgen.emitters.site&#45;&gt;docgen.emitters.index -->
-<g id="edge59" class="edge imports">
+<g id="edge84" class="edge imports">
 <title>docgen.emitters.site&#45;&gt;docgen.emitters.index</title>
-<path fill="none" stroke="#4a4a4a" d="M446.47,-108.28C453.93,-103.37 461.91,-97.88 469.06,-92.5 480.4,-83.97 492.41,-73.91 502.54,-65.09"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="503.69,-66.87 506.82,-61.34 500.92,-63.72 503.69,-66.87"/>
+<path fill="none" stroke="#4a4a4a" d="M400.09,-102.53C399.56,-92.29 398.88,-79.19 398.29,-67.88"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="400.39,-67.8 397.98,-61.91 396.2,-68.02 400.39,-67.8"/>
 </g>
 <!-- docgen.extractors.code&#45;&gt;docgen.book.larder -->
-<g id="edge60" class="edge imports">
+<g id="edge85" class="edge imports">
 <title>docgen.extractors.code&#45;&gt;docgen.book.larder</title>
-<path fill="none" stroke="#4a4a4a" d="M1886.47,-279.62C1880.56,-276.65 1874.24,-273.91 1868.06,-272 1735.2,-230.83 1695.04,-254.56 1557.06,-237 1394.08,-216.26 1353.97,-206.37 1191.06,-185 1028.96,-163.74 835.52,-141.4 753.27,-132.04"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="753.83,-129.99 747.63,-131.4 753.35,-134.17 753.83,-129.99"/>
+<path fill="none" stroke="#4a4a4a" d="M1701.3,-279.7C1696.9,-276.57 1692.02,-273.74 1687,-272 1644.69,-257.31 1324.1,-283.94 1284,-264 1233.74,-239.01 1199.05,-179.67 1182.7,-146.14"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1184.62,-145.28 1180.14,-140.77 1180.83,-147.09 1184.62,-145.28"/>
 </g>
 <!-- docgen.extractors.code&#45;&gt;docgen.ir.model -->
-<g id="edge61" class="edge imports">
+<g id="edge86" class="edge imports">
 <title>docgen.extractors.code&#45;&gt;docgen.ir.model</title>
-<path fill="none" stroke="#4a4a4a" d="M1895.6,-279.81C1867.87,-255.34 1815.99,-209.53 1776.33,-174.52"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1778.08,-173.27 1772.2,-170.88 1775.3,-176.42 1778.08,-173.27"/>
+<path fill="none" stroke="#4a4a4a" d="M1729.75,-279.58C1742.92,-256.08 1766.98,-213.1 1786.66,-177.96"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1788.44,-179.08 1789.54,-172.82 1784.78,-177.03 1788.44,-179.08"/>
 </g>
 <!-- tree_sitter -->
 <g id="tree_sitter" class="node external">
 <title>tree_sitter</title>
-<path fill="#141414" stroke="#555568" stroke-dasharray="5,2" d="M2344.71,-237C2344.71,-237 2275.41,-237 2275.41,-237 2269.41,-237 2263.41,-231 2263.41,-225 2263.41,-225 2263.41,-213 2263.41,-213 2263.41,-207 2269.41,-201 2275.41,-201 2275.41,-201 2344.71,-201 2344.71,-201 2350.71,-201 2356.71,-207 2356.71,-213 2356.71,-213 2356.71,-225 2356.71,-225 2356.71,-231 2350.71,-237 2344.71,-237"/>
-<text xml:space="preserve" text-anchor="middle" x="2310.06" y="-215.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#a3a3a3">tree_sitter</text>
+<path fill="#141414" stroke="#555568" stroke-dasharray="5,2" d="M3421.65,-231.5C3421.65,-231.5 3352.35,-231.5 3352.35,-231.5 3346.35,-231.5 3340.35,-225.5 3340.35,-219.5 3340.35,-219.5 3340.35,-207.5 3340.35,-207.5 3340.35,-201.5 3346.35,-195.5 3352.35,-195.5 3352.35,-195.5 3421.65,-195.5 3421.65,-195.5 3427.65,-195.5 3433.65,-201.5 3433.65,-207.5 3433.65,-207.5 3433.65,-219.5 3433.65,-219.5 3433.65,-225.5 3427.65,-231.5 3421.65,-231.5"/>
+<text xml:space="preserve" text-anchor="middle" x="3387" y="-209.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#a3a3a3">tree_sitter</text>
 </g>
 <!-- docgen.extractors.code&#45;&gt;tree_sitter -->
-<g id="edge62" class="edge imports">
+<g id="edge87" class="edge imports">
 <title>docgen.extractors.code&#45;&gt;tree_sitter</title>
-<path fill="none" stroke="#4a4a4a" d="M1944.44,-292.49C2002.41,-283.41 2135.48,-261.67 2246.06,-237 2249.24,-236.29 2252.5,-235.53 2255.78,-234.74"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2256.19,-236.8 2261.51,-233.33 2255.19,-232.72 2256.19,-236.8"/>
+<path fill="none" stroke="#4a4a4a" d="M1747.71,-279.57C1753.85,-276.49 1760.48,-273.72 1767,-272 1799.78,-263.37 2038.12,-265.08 2072,-264 2561.33,-248.37 3152.89,-224.22 3332.64,-216.77"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="3332.71,-218.87 3338.61,-216.52 3332.53,-214.67 3332.71,-218.87"/>
 </g>
 <!-- docgen.extractors.db&#45;&gt;docgen.book.larder -->
-<g id="edge63" class="edge imports">
+<g id="edge88" class="edge imports">
 <title>docgen.extractors.db&#45;&gt;docgen.book.larder</title>
-<path fill="none" stroke="#4a4a4a" d="M1682.93,-279.66C1677.25,-276.61 1671.12,-273.83 1665.06,-272 1559.08,-239.97 1266.8,-287.09 1168.06,-237 1141.06,-223.3 1150.58,-199.61 1124.06,-185 1060.77,-150.11 844.29,-134.59 753.57,-129.51"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="753.84,-127.42 747.73,-129.19 753.61,-131.62 753.84,-127.42"/>
+<path fill="none" stroke="#4a4a4a" d="M1887.79,-279.65C1881.84,-276.52 1875.39,-273.71 1869,-272 1841.68,-264.69 1385.13,-276.98 1360,-264 1318.61,-242.62 1334.13,-208.9 1298,-179.5 1272.49,-158.74 1238.27,-143.75 1211.93,-134.29"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1212.86,-132.39 1206.5,-132.39 1211.47,-136.36 1212.86,-132.39"/>
 </g>
 <!-- docgen.extractors.db&#45;&gt;docgen.ir.model -->
-<g id="edge64" class="edge imports">
+<g id="edge89" class="edge imports">
 <title>docgen.extractors.db&#45;&gt;docgen.ir.model</title>
-<path fill="none" stroke="#4a4a4a" d="M1710.48,-279.81C1712.32,-257.59 1715.61,-217.79 1718.36,-184.44"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1720.45,-184.66 1718.85,-178.5 1716.26,-184.31 1720.45,-184.66"/>
+<path fill="none" stroke="#4a4a4a" d="M1904.44,-279.58C1891.55,-256.08 1867.98,-213.1 1848.7,-177.96"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1850.61,-177.07 1845.88,-172.82 1846.93,-179.09 1850.61,-177.07"/>
 </g>
 <!-- docgen.extractors.openapi&#45;&gt;docgen.__main__ -->
-<g id="edge65" class="edge imports">
+<g id="edge90" class="edge imports">
 <title>docgen.extractors.openapi&#45;&gt;docgen.__main__</title>
-<path fill="none" stroke="#4a4a4a" d="M1776.47,-279.52C1769.23,-276.52 1761.52,-273.8 1754.06,-272 1500.42,-210.87 1428.2,-256.98 1168.06,-237 1122.63,-233.51 1070.87,-228.55 1034.38,-224.89"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1034.97,-222.84 1028.79,-224.32 1034.55,-227.02 1034.97,-222.84"/>
+<path fill="none" stroke="#4a4a4a" d="M2008.41,-316.24C1999.47,-335.41 1982.76,-364.96 1959,-381 1952.21,-385.59 1949.15,-384.11 1941,-385 1916.54,-387.69 1522.46,-387.69 1498,-385 1436,-378.19 1371.03,-343.85 1332.82,-320.41"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1333.95,-318.64 1327.75,-317.25 1331.73,-322.21 1333.95,-318.64"/>
 </g>
 <!-- docgen.extractors.openapi&#45;&gt;docgen.book.larder -->
-<g id="edge66" class="edge imports">
+<g id="edge91" class="edge imports">
 <title>docgen.extractors.openapi&#45;&gt;docgen.book.larder</title>
-<path fill="none" stroke="#4a4a4a" d="M1776.46,-279.54C1769.22,-276.54 1761.52,-273.81 1754.06,-272 1635.49,-243.17 1316.76,-288.36 1206.06,-237 1176.98,-223.51 1184.69,-199.44 1156.06,-185 1085.86,-149.6 848.96,-134.21 753.47,-129.33"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="753.63,-127.24 747.54,-129.04 753.42,-131.43 753.63,-127.24"/>
+<path fill="none" stroke="#4a4a4a" d="M1982.07,-279.53C1974.65,-276.45 1966.71,-273.69 1959,-272 1910.48,-261.37 1560.3,-275.62 1512,-264 1428.8,-243.98 1418.05,-212.27 1339,-179.5 1296.42,-161.85 1246.27,-145.1 1212.12,-134.28"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1212.88,-132.32 1206.53,-132.52 1211.62,-136.33 1212.88,-132.32"/>
 </g>
 <!-- docgen.extractors.openapi&#45;&gt;docgen.ir.model -->
-<g id="edge67" class="edge imports">
+<g id="edge92" class="edge imports">
 <title>docgen.extractors.openapi&#45;&gt;docgen.ir.model</title>
-<path fill="none" stroke="#4a4a4a" d="M1802.14,-279.81C1790.51,-257.41 1769.59,-217.12 1752.19,-183.6"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1754.09,-182.7 1749.46,-178.34 1750.36,-184.63 1754.09,-182.7"/>
+<path fill="none" stroke="#4a4a4a" d="M1996.82,-279.81C1971.18,-256.86 1924.29,-214.98 1884,-179.5 1879.91,-175.9 1875.67,-172.18 1871.41,-168.44"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1873.04,-167.08 1867.14,-164.71 1870.27,-170.24 1873.04,-167.08"/>
 </g>
 <!-- modelgen.loader.extract.openapi -->
 <g id="modelgen.loader.extract.openapi" class="node external">
 <title>modelgen.loader.extract.openapi</title>
-<path fill="#141414" stroke="#555568" stroke-dasharray="5,2" d="M2215.84,-237C2215.84,-237 2162.29,-237 2162.29,-237 2156.29,-237 2150.29,-231 2150.29,-225 2150.29,-225 2150.29,-213 2150.29,-213 2150.29,-207 2156.29,-201 2162.29,-201 2162.29,-201 2215.84,-201 2215.84,-201 2221.84,-201 2227.84,-207 2227.84,-213 2227.84,-213 2227.84,-225 2227.84,-225 2227.84,-231 2221.84,-237 2215.84,-237"/>
-<text xml:space="preserve" text-anchor="middle" x="2189.06" y="-215.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#a3a3a3">openapi</text>
+<path fill="#141414" stroke="#555568" stroke-dasharray="5,2" d="M3629.78,-231.5C3629.78,-231.5 3576.22,-231.5 3576.22,-231.5 3570.22,-231.5 3564.22,-225.5 3564.22,-219.5 3564.22,-219.5 3564.22,-207.5 3564.22,-207.5 3564.22,-201.5 3570.22,-195.5 3576.22,-195.5 3576.22,-195.5 3629.78,-195.5 3629.78,-195.5 3635.78,-195.5 3641.78,-201.5 3641.78,-207.5 3641.78,-207.5 3641.78,-219.5 3641.78,-219.5 3641.78,-225.5 3635.78,-231.5 3629.78,-231.5"/>
+<text xml:space="preserve" text-anchor="middle" x="3603" y="-209.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#a3a3a3">openapi</text>
 </g>
 <!-- docgen.extractors.openapi&#45;&gt;modelgen.loader.extract.openapi -->
-<g id="edge68" class="edge imports">
+<g id="edge93" class="edge imports">
 <title>docgen.extractors.openapi&#45;&gt;modelgen.loader.extract.openapi</title>
-<path fill="none" stroke="#4a4a4a" d="M1846.68,-279.56C1853.65,-276.67 1860.99,-273.98 1868.06,-272 1982.05,-240.14 2016.32,-261.77 2132.06,-237 2135.63,-236.24 2139.3,-235.36 2142.98,-234.42"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2143.31,-236.5 2148.56,-232.92 2142.22,-232.44 2143.31,-236.5"/>
+<path fill="none" stroke="#4a4a4a" d="M2042.81,-279.6C2048.89,-276.47 2055.49,-273.67 2062,-272 2101.92,-261.74 3507.42,-278.53 3546,-264 3560.62,-258.49 3573.99,-247.38 3584.09,-237.08"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="3585.45,-238.7 3588.03,-232.9 3582.39,-235.82 3585.45,-238.7"/>
 </g>
 <!-- yaml -->
 <g id="yaml" class="node external">
 <title>yaml</title>
-<path fill="#141414" stroke="#555568" stroke-dasharray="5,2" d="M2102.46,-237C2102.46,-237 2067.66,-237 2067.66,-237 2061.66,-237 2055.66,-231 2055.66,-225 2055.66,-225 2055.66,-213 2055.66,-213 2055.66,-207 2061.66,-201 2067.66,-201 2067.66,-201 2102.46,-201 2102.46,-201 2108.46,-201 2114.46,-207 2114.46,-213 2114.46,-213 2114.46,-225 2114.46,-225 2114.46,-231 2108.46,-237 2102.46,-237"/>
-<text xml:space="preserve" text-anchor="middle" x="2085.06" y="-215.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#a3a3a3">yaml</text>
+<path fill="#141414" stroke="#555568" stroke-dasharray="5,2" d="M3516.4,-231.5C3516.4,-231.5 3481.6,-231.5 3481.6,-231.5 3475.6,-231.5 3469.6,-225.5 3469.6,-219.5 3469.6,-219.5 3469.6,-207.5 3469.6,-207.5 3469.6,-201.5 3475.6,-195.5 3481.6,-195.5 3481.6,-195.5 3516.4,-195.5 3516.4,-195.5 3522.4,-195.5 3528.4,-201.5 3528.4,-207.5 3528.4,-207.5 3528.4,-219.5 3528.4,-219.5 3528.4,-225.5 3522.4,-231.5 3516.4,-231.5"/>
+<text xml:space="preserve" text-anchor="middle" x="3499" y="-209.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#a3a3a3">yaml</text>
 </g>
 <!-- docgen.extractors.openapi&#45;&gt;yaml -->
-<g id="edge69" class="edge imports">
+<g id="edge94" class="edge imports">
 <title>docgen.extractors.openapi&#45;&gt;yaml</title>
-<path fill="none" stroke="#4a4a4a" d="M1848.09,-279.62C1854.67,-276.87 1861.51,-274.2 1868.06,-272 1930.03,-251.17 2004.58,-235.21 2048.21,-226.75"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2048.48,-228.83 2053.98,-225.64 2047.69,-224.71 2048.48,-228.83"/>
+<path fill="none" stroke="#4a4a4a" d="M2042.81,-279.6C2048.89,-276.47 2055.49,-273.68 2062,-272 2099.39,-262.38 3416.57,-279.34 3452,-264 3464.73,-258.49 3475.64,-247.67 3483.74,-237.55"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="3485.3,-238.97 3487.26,-232.92 3481.95,-236.43 3485.3,-238.97"/>
 </g>
 <!-- docgen.extractors.python.resolve -->
 <g id="docgen.extractors.python.resolve" class="node module">
 <title>docgen.extractors.python.resolve</title>
 <g id="a_docgen.extractors.python.resolve"><a xlink:href="extractors/python/resolve.py" xlink:title="Pass two: turn collected names into ids, and collected facts into an IR.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1636.34,-237C1636.34,-237 1585.79,-237 1585.79,-237 1579.79,-237 1573.79,-231 1573.79,-225 1573.79,-225 1573.79,-213 1573.79,-213 1573.79,-207 1579.79,-201 1585.79,-201 1585.79,-201 1636.34,-201 1636.34,-201 1642.34,-201 1648.34,-207 1648.34,-213 1648.34,-213 1648.34,-225 1648.34,-225 1648.34,-231 1642.34,-237 1636.34,-237"/>
-<text xml:space="preserve" text-anchor="middle" x="1611.06" y="-215.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">resolve</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1659.28,-231.5C1659.28,-231.5 1608.72,-231.5 1608.72,-231.5 1602.72,-231.5 1596.72,-225.5 1596.72,-219.5 1596.72,-219.5 1596.72,-207.5 1596.72,-207.5 1596.72,-201.5 1602.72,-195.5 1608.72,-195.5 1608.72,-195.5 1659.28,-195.5 1659.28,-195.5 1665.28,-195.5 1671.28,-201.5 1671.28,-207.5 1671.28,-207.5 1671.28,-219.5 1671.28,-219.5 1671.28,-225.5 1665.28,-231.5 1659.28,-231.5"/>
+<text xml:space="preserve" text-anchor="middle" x="1634" y="-209.8" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">resolve</text>
 </a>
 </g>
 </g>
 <!-- docgen.extractors.python.collect&#45;&gt;docgen.extractors.python.resolve -->
-<g id="edge70" class="edge imports">
+<g id="edge95" class="edge imports">
 <title>docgen.extractors.python.collect&#45;&gt;docgen.extractors.python.resolve</title>
-<path fill="none" stroke="#4a4a4a" d="M1599.54,-279.53C1597.37,-269.19 1596.99,-255.94 1598.38,-244.56"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1600.41,-245.16 1599.31,-238.9 1596.27,-244.48 1600.41,-245.16"/>
+<path fill="none" stroke="#4a4a4a" d="M1611.7,-279.5C1611.19,-267.69 1613.48,-251.94 1617.42,-238.89"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1619.34,-239.76 1619.28,-233.4 1615.36,-238.41 1619.34,-239.76"/>
 </g>
 <!-- docgen.extractors.python.resolve&#45;&gt;docgen.book.larder -->
-<g id="edge71" class="edge imports">
+<g id="edge96" class="edge imports">
 <title>docgen.extractors.python.resolve&#45;&gt;docgen.book.larder</title>
-<path fill="none" stroke="#4a4a4a" d="M1573.38,-214.26C1501.01,-207.09 1337.58,-190.85 1200.06,-177 1034.26,-160.3 836.74,-140.14 753.36,-131.62"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="753.82,-129.56 747.63,-131.04 753.39,-133.74 753.82,-129.56"/>
+<path fill="none" stroke="#4a4a4a" d="M1596.3,-205.88C1551.74,-198 1475.38,-184.28 1410,-171.5 1340.41,-157.9 1259.65,-140.83 1212.36,-130.7"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1212.85,-128.66 1206.54,-129.46 1211.97,-132.77 1212.85,-128.66"/>
 </g>
 <!-- docgen.extractors.python.resolve&#45;&gt;docgen.extractors.python.collect -->
-<g id="edge72" class="edge imports">
+<g id="edge97" class="edge imports">
 <title>docgen.extractors.python.resolve&#45;&gt;docgen.extractors.python.collect</title>
-<path fill="none" stroke="#4a4a4a" d="M1622.57,-237.4C1624.75,-247.73 1625.14,-260.98 1623.75,-272.36"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1621.72,-271.77 1622.83,-278.03 1625.87,-272.45 1621.72,-271.77"/>
+<path fill="none" stroke="#4a4a4a" d="M1642.3,-231.97C1642.81,-243.78 1640.53,-259.53 1636.59,-272.58"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1634.67,-271.71 1634.73,-278.07 1638.64,-273.06 1634.67,-271.71"/>
 </g>
 <!-- docgen.extractors.python.resolve&#45;&gt;docgen.ir.model -->
-<g id="edge73" class="edge imports">
+<g id="edge98" class="edge imports">
 <title>docgen.extractors.python.resolve&#45;&gt;docgen.ir.model</title>
-<path fill="none" stroke="#4a4a4a" d="M1632.66,-200.55C1643.22,-192.02 1656.44,-181.33 1669.49,-170.79"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1670.54,-172.64 1673.89,-167.23 1667.9,-169.37 1670.54,-172.64"/>
+<path fill="none" stroke="#4a4a4a" d="M1653.16,-195.14C1659.77,-189.68 1667.43,-183.93 1675,-179.5 1702.67,-163.29 1735.78,-149.65 1763.17,-139.73"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1763.63,-141.8 1768.58,-137.8 1762.22,-137.84 1763.63,-141.8"/>
 </g>
 <!-- docgen.extractors.usage&#45;&gt;docgen.book.larder -->
-<g id="edge74" class="edge imports">
+<g id="edge99" class="edge imports">
 <title>docgen.extractors.usage&#45;&gt;docgen.book.larder</title>
-<path fill="none" stroke="#4a4a4a" d="M1482.98,-279.54C1477.93,-276.58 1472.48,-273.86 1467.06,-272 1324.66,-223.06 1258.09,-316.27 1130.06,-237 1106.79,-222.59 1120,-199.93 1097.06,-185 1040.86,-148.42 840.09,-133.97 753.4,-129.34"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="753.73,-127.26 747.63,-129.04 753.51,-131.45 753.73,-127.26"/>
+<path fill="none" stroke="#4a4a4a" d="M1787.8,-279.53C1781.15,-276.45 1774,-273.69 1767,-272 1742.96,-266.2 1344.24,-274.8 1322,-264 1278.38,-242.82 1288.42,-212.61 1253,-179.5 1238.89,-166.31 1221.62,-153.66 1206.66,-143.59"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1207.83,-141.85 1201.67,-140.28 1205.51,-145.35 1207.83,-141.85"/>
 </g>
 <!-- docgen.extractors.usage&#45;&gt;docgen.ir.model -->
-<g id="edge75" class="edge imports">
+<g id="edge100" class="edge imports">
 <title>docgen.extractors.usage&#45;&gt;docgen.ir.model</title>
-<path fill="none" stroke="#4a4a4a" d="M1540.09,-279.62C1545.69,-276.92 1551.49,-274.28 1557.06,-272 1603.76,-252.89 1626.42,-269.45 1665.06,-237 1681.77,-222.97 1694.34,-202.88 1703.43,-183.72"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1705.29,-184.7 1705.87,-178.37 1701.47,-182.96 1705.29,-184.7"/>
+<path fill="none" stroke="#4a4a4a" d="M1818,-279.58C1818,-256.27 1818,-213.81 1818,-178.84"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1820.1,-179.01 1818,-173.01 1815.9,-179.01 1820.1,-179.01"/>
 </g>
 <!-- docgen.ir.model&#45;&gt;docgen.ir.validate -->
-<g id="edge76" class="edge imports">
+<g id="edge101" class="edge imports">
 <title>docgen.ir.model&#45;&gt;docgen.ir.validate</title>
-<path fill="none" stroke="#4a4a4a" d="M1711.79,-108C1709.31,-96.3 1708.9,-80.73 1710.57,-67.76"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1712.62,-68.23 1711.54,-61.96 1708.48,-67.53 1712.62,-68.23"/>
+<path fill="none" stroke="#4a4a4a" d="M1806.48,-102.53C1804.31,-92.19 1803.92,-78.94 1805.32,-67.56"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1807.35,-68.16 1806.25,-61.9 1803.2,-67.48 1807.35,-68.16"/>
 </g>
 <!-- docgen.ir.validate&#45;&gt;docgen.ir.model -->
-<g id="edge77" class="edge imports">
+<g id="edge102" class="edge imports">
 <title>docgen.ir.validate&#45;&gt;docgen.ir.model</title>
-<path fill="none" stroke="#4a4a4a" d="M1734.33,-60.47C1736.82,-72.17 1737.23,-87.74 1735.56,-100.71"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1733.51,-100.25 1734.58,-106.51 1737.65,-100.94 1733.51,-100.25"/>
+<path fill="none" stroke="#4a4a4a" d="M1829.51,-60.4C1831.68,-70.73 1832.08,-83.98 1830.69,-95.36"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1828.66,-94.77 1829.77,-101.03 1832.8,-95.45 1828.66,-94.77"/>
 </g>
 <!-- docgen.lab.pg_probe -->
 <g id="docgen.lab.pg_probe" class="node module">
 <title>docgen.lab.pg_probe</title>
 <g id="a_docgen.lab.pg_probe"><a xlink:href="lab/pg_probe.py" xlink:title="EXPERIMENT — a live PostgreSQL schema, as a graphgen&#45;compatible `schema.json`.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1612.21,-433C1612.21,-433 1551.91,-433 1551.91,-433 1545.91,-433 1539.91,-427 1539.91,-421 1539.91,-421 1539.91,-409 1539.91,-409 1539.91,-403 1545.91,-397 1551.91,-397 1551.91,-397 1612.21,-397 1612.21,-397 1618.21,-397 1624.21,-403 1624.21,-409 1624.21,-409 1624.21,-421 1624.21,-421 1624.21,-427 1618.21,-433 1612.21,-433"/>
-<text xml:space="preserve" text-anchor="middle" x="1582.06" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">pg_probe</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M3076.15,-433C3076.15,-433 3015.85,-433 3015.85,-433 3009.85,-433 3003.85,-427 3003.85,-421 3003.85,-421 3003.85,-409 3003.85,-409 3003.85,-403 3009.85,-397 3015.85,-397 3015.85,-397 3076.15,-397 3076.15,-397 3082.15,-397 3088.15,-403 3088.15,-409 3088.15,-409 3088.15,-421 3088.15,-421 3088.15,-427 3082.15,-433 3076.15,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="3046" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">pg_probe</text>
 </a>
 </g>
 </g>
+<!-- docgen.ops.pages&#45;&gt;docgen.ops.filter -->
+<g id="edge103" class="edge imports">
+<title>docgen.ops.pages&#45;&gt;docgen.ops.filter</title>
+<path fill="none" stroke="#4a4a4a" d="M932.55,-102.53C932.28,-92.29 931.94,-79.19 931.65,-67.88"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="933.75,-67.86 931.49,-61.92 929.55,-67.97 933.75,-67.86"/>
+</g>
 <!-- docgen.reference -->
 <g id="docgen.reference" class="node module">
 <title>docgen.reference</title>
 <g id="a_docgen.reference"><a xlink:href="reference.py" xlink:title="Where the rest of spr is, when docgen is not inside it.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1843.09,-433C1843.09,-433 1779.04,-433 1779.04,-433 1773.04,-433 1767.04,-427 1767.04,-421 1767.04,-421 1767.04,-409 1767.04,-409 1767.04,-403 1773.04,-397 1779.04,-397 1779.04,-397 1843.09,-397 1843.09,-397 1849.09,-397 1855.09,-403 1855.09,-409 1855.09,-409 1855.09,-421 1855.09,-421 1855.09,-427 1849.09,-433 1843.09,-433"/>
-<text xml:space="preserve" text-anchor="middle" x="1811.06" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">reference</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M3200.03,-433C3200.03,-433 3135.97,-433 3135.97,-433 3129.97,-433 3123.97,-427 3123.97,-421 3123.97,-421 3123.97,-409 3123.97,-409 3123.97,-403 3129.97,-397 3135.97,-397 3135.97,-397 3200.03,-397 3200.03,-397 3206.03,-397 3212.03,-403 3212.03,-409 3212.03,-409 3212.03,-421 3212.03,-421 3212.03,-427 3206.03,-433 3200.03,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="3168" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">reference</text>
 </a>
 </g>
 </g>
@@ -854,49 +1082,49 @@
 <g id="docgen.selftest" class="node module">
 <title>docgen.selftest</title>
 <g id="a_docgen.selftest"><a xlink:href="selftest.py" xlink:title="Prove the pipeline, offline, on a tree it builds itself.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M2008.09,-433C2008.09,-433 1956.04,-433 1956.04,-433 1950.04,-433 1944.04,-427 1944.04,-421 1944.04,-421 1944.04,-409 1944.04,-409 1944.04,-403 1950.04,-397 1956.04,-397 1956.04,-397 2008.09,-397 2008.09,-397 2014.09,-397 2020.09,-403 2020.09,-409 2020.09,-409 2020.09,-421 2020.09,-421 2020.09,-427 2014.09,-433 2008.09,-433"/>
-<text xml:space="preserve" text-anchor="middle" x="1982.06" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">selftest</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M3312.03,-433C3312.03,-433 3259.97,-433 3259.97,-433 3253.97,-433 3247.97,-427 3247.97,-421 3247.97,-421 3247.97,-409 3247.97,-409 3247.97,-403 3253.97,-397 3259.97,-397 3259.97,-397 3312.03,-397 3312.03,-397 3318.03,-397 3324.03,-403 3324.03,-409 3324.03,-409 3324.03,-421 3324.03,-421 3324.03,-427 3318.03,-433 3312.03,-433"/>
+<text xml:space="preserve" text-anchor="middle" x="3286" y="-411.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">selftest</text>
 </a>
 </g>
 </g>
 <!-- lxml -->
 <g id="lxml" class="node external">
 <title>lxml</title>
-<path fill="#141414" stroke="#555568" stroke-dasharray="5,2" d="M2253.21,-60C2253.21,-60 2222.91,-60 2222.91,-60 2216.91,-60 2210.91,-54 2210.91,-48 2210.91,-48 2210.91,-36 2210.91,-36 2210.91,-30 2216.91,-24 2222.91,-24 2222.91,-24 2253.21,-24 2253.21,-24 2259.21,-24 2265.21,-30 2265.21,-36 2265.21,-36 2265.21,-48 2265.21,-48 2265.21,-54 2259.21,-60 2253.21,-60"/>
-<text xml:space="preserve" text-anchor="middle" x="2238.06" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#a3a3a3">lxml</text>
+<path fill="#141414" stroke="#555568" stroke-dasharray="5,2" d="M3547.15,-60C3547.15,-60 3516.85,-60 3516.85,-60 3510.85,-60 3504.85,-54 3504.85,-48 3504.85,-48 3504.85,-36 3504.85,-36 3504.85,-30 3510.85,-24 3516.85,-24 3516.85,-24 3547.15,-24 3547.15,-24 3553.15,-24 3559.15,-30 3559.15,-36 3559.15,-36 3559.15,-48 3559.15,-48 3559.15,-54 3553.15,-60 3547.15,-60"/>
+<text xml:space="preserve" text-anchor="middle" x="3532" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#a3a3a3">lxml</text>
 </g>
 <!-- docgen.selftest&#45;&gt;lxml -->
-<g id="edge78" class="edge imports">
+<g id="edge104" class="edge imports">
 <title>docgen.selftest&#45;&gt;lxml</title>
-<path fill="none" stroke="#4a4a4a" d="M2020.43,-410.1C2102.56,-399.46 2294.43,-361.75 2375.06,-237 2416.9,-172.28 2324.62,-98.65 2271.76,-63.63"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2272.96,-61.9 2266.79,-60.38 2270.66,-65.42 2272.96,-61.9"/>
+<path fill="none" stroke="#4a4a4a" d="M3324.44,-411.94C3403.39,-405.38 3582.89,-378.01 3660,-264 3707.48,-193.8 3612.71,-105.23 3561.63,-64.86"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="3563.15,-63.37 3557.13,-61.34 3560.56,-66.68 3563.15,-63.37"/>
 </g>
 <!-- docgen.style.tokens -->
 <g id="docgen.style.tokens" class="node module">
 <title>docgen.style.tokens</title>
 <g id="a_docgen.style.tokens"><a xlink:href="style/tokens.py" xlink:title="A harvested token vocabulary &#45;&gt; a **theme**.">
-<path fill="#1a1a1a" stroke="#4a4a4a" d="M1277.09,-60C1277.09,-60 1231.04,-60 1231.04,-60 1225.04,-60 1219.04,-54 1219.04,-48 1219.04,-48 1219.04,-36 1219.04,-36 1219.04,-30 1225.04,-24 1231.04,-24 1231.04,-24 1277.09,-24 1277.09,-24 1283.09,-24 1289.09,-30 1289.09,-36 1289.09,-36 1289.09,-48 1289.09,-48 1289.09,-54 1283.09,-60 1277.09,-60"/>
-<text xml:space="preserve" text-anchor="middle" x="1254.06" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">tokens</text>
+<path fill="#1a1a1a" stroke="#4a4a4a" d="M1487.03,-60C1487.03,-60 1440.97,-60 1440.97,-60 1434.97,-60 1428.97,-54 1428.97,-48 1428.97,-48 1428.97,-36 1428.97,-36 1428.97,-30 1434.97,-24 1440.97,-24 1440.97,-24 1487.03,-24 1487.03,-24 1493.03,-24 1499.03,-30 1499.03,-36 1499.03,-36 1499.03,-48 1499.03,-48 1499.03,-54 1493.03,-60 1487.03,-60"/>
+<text xml:space="preserve" text-anchor="middle" x="1464" y="-38.3" font-family="Helvetica,sans-Serif" font-weight="bold" font-size="11.00" fill="#e5e5e5">tokens</text>
 </a>
 </g>
 </g>
 <!-- docgen.style.extract&#45;&gt;docgen.style.tokens -->
-<g id="edge79" class="edge imports">
+<g id="edge105" class="edge imports">
 <title>docgen.style.extract&#45;&gt;docgen.style.tokens</title>
-<path fill="none" stroke="#4a4a4a" d="M1242.79,-108C1240.31,-96.3 1239.9,-80.73 1241.57,-67.76"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1243.62,-68.23 1242.54,-61.96 1239.48,-67.53 1243.62,-68.23"/>
+<path fill="none" stroke="#4a4a4a" d="M1452.48,-102.53C1450.31,-92.19 1449.92,-78.94 1451.32,-67.56"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1453.35,-68.16 1452.25,-61.9 1449.2,-67.48 1453.35,-68.16"/>
 </g>
 <!-- docgen.style.extract&#45;&gt;lxml -->
-<g id="edge80" class="edge imports">
+<g id="edge106" class="edge imports">
 <title>docgen.style.extract&#45;&gt;lxml</title>
-<path fill="none" stroke="#4a4a4a" d="M1291.05,-123.28C1402.73,-116.55 1731.74,-96.62 1780.06,-92.5 1938.51,-78.97 2127.12,-56.6 2203.45,-47.28"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="2203.28,-49.42 2208.98,-46.6 2202.77,-45.25 2203.28,-49.42"/>
+<path fill="none" stroke="#4a4a4a" d="M1501,-116.23C1557.14,-110.66 1667.23,-100.32 1761,-95 2459.61,-55.37 3315.06,-45.11 3496.97,-43.32"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="3496.9,-45.42 3502.88,-43.26 3496.86,-41.22 3496.9,-45.42"/>
 </g>
 <!-- docgen.style.tokens&#45;&gt;docgen.style.extract -->
-<g id="edge81" class="edge imports">
+<g id="edge107" class="edge imports">
 <title>docgen.style.tokens&#45;&gt;docgen.style.extract</title>
-<path fill="none" stroke="#4a4a4a" d="M1265.33,-60.47C1267.82,-72.17 1268.23,-87.74 1266.56,-100.71"/>
-<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1264.51,-100.25 1265.58,-106.51 1268.65,-100.94 1264.51,-100.25"/>
+<path fill="none" stroke="#4a4a4a" d="M1475.51,-60.4C1477.68,-70.73 1478.08,-83.98 1476.69,-95.36"/>
+<polygon fill="#4a4a4a" stroke="#4a4a4a" points="1474.66,-94.77 1475.77,-101.03 1478.8,-95.45 1474.66,-94.77"/>
 </g>
 </g>
 </svg>
diff --git a/soleprint/atlas2/docgen/docs/img/minimap.svg b/soleprint/atlas2/docgen/docs/img/minimap.svg
index dcdef6d..c132b2f 100644
--- a/soleprint/atlas2/docgen/docs/img/minimap.svg
+++ b/soleprint/atlas2/docgen/docs/img/minimap.svg
@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no"?>
-<svg xmlns="http://www.w3.org/2000/svg" width="886pt" height="2238pt" viewBox="0 0 886 2238">
-<rect width="886" height="2238" fill="#0a0a0a"/>
-<rect x="28.0" y="46.0" width="74.0" height="1164.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.selftest — 2328 lines</title></rect>
+<svg xmlns="http://www.w3.org/2000/svg" width="886pt" height="2781pt" viewBox="0 0 886 2781">
+<rect width="886" height="2781" fill="#0a0a0a"/>
+<rect x="28.0" y="46.0" width="74.0" height="1387.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.selftest — 2775 lines</title></rect>
 <rect x="28.0" y="94.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.selftest.own_py_files" data-kind="function" class="blk"><title>own_py_files — function, 3 lines</title></rect>
 <rect x="28.0" y="96.0" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.selftest.check" data-kind="function" class="blk"><title>check — function, 5 lines</title></rect>
 <rect x="28.0" y="99.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.selftest._err" data-kind="function" class="blk"><title>_err — function, 7 lines</title></rect>
@@ -15,6 +15,12 @@
 <rect x="28.0" y="1106.5" width="74.0" height="97.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.selftest._runfiles" data-kind="function" class="blk"><title>_runfiles — function, 195 lines</title></rect>
 <rect x="35.0" y="1112.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.selftest._runfiles.write" data-kind="function" class="blk"><title>write — function, 4 lines</title></rect>
 <rect x="35.0" y="1115.0" width="60.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.selftest._runfiles.problems" data-kind="function" class="blk"><title>problems — function, 6 lines</title></rect>
+<rect x="28.0" y="1209.0" width="74.0" height="57.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.selftest._pages" data-kind="function" class="blk"><title>_pages — function, 114 lines</title></rect>
+<rect x="28.0" y="1270.5" width="74.0" height="80.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.selftest._documents" data-kind="function" class="blk"><title>_documents — function, 161 lines</title></rect>
+<rect x="28.0" y="1355.5" width="74.0" height="29.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.selftest._projects" data-kind="function" class="blk"><title>_projects — function, 59 lines</title></rect>
+<rect x="35.0" y="1359.5" width="60.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.selftest._projects.load" data-kind="function" class="blk"><title>load — function, 7 lines</title></rect>
+<rect x="28.0" y="1390.0" width="74.0" height="37.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.selftest._contract" data-kind="function" class="blk"><title>_contract — function, 75 lines</title></rect>
+<rect x="35.0" y="1399.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.selftest._contract.named" data-kind="function" class="blk"><title>named — function, 2 lines</title></rect>
 <rect x="110.0" y="46.0" width="74.0" height="158.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.book — 316 lines</title></rect>
 <rect x="110.0" y="75.0" width="74.0" height="10.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.Step" data-kind="class" class="blk"><title>Step — class, 20 lines</title></rect>
 <rect x="117.0" y="80.0" width="60.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.Step.to_dict" data-kind="function" class="blk"><title>to_dict — function, 10 lines</title></rect>
@@ -54,353 +60,449 @@
 <rect x="274.0" y="82.0" width="74.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.reference.describe" data-kind="function" class="blk"><title>describe — function, 10 lines</title></rect>
 <rect x="274.0" y="88.0" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.reference.on_path" data-kind="function" class="blk"><title>on_path — function, 13 lines</title></rect>
 <rect x="274.0" y="95.5" width="74.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.reference.missing" data-kind="function" class="blk"><title>missing — function, 8 lines</title></rect>
-<rect x="356.0" y="46.0" width="74.0" height="38.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli — 76 lines</title></rect>
-<rect x="356.0" y="68.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.usage" data-kind="function" class="blk"><title>usage — function, 7 lines</title></rect>
-<rect x="356.0" y="73.0" width="74.0" height="10.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.main" data-kind="function" class="blk"><title>main — function, 21 lines</title></rect>
+<rect x="356.0" y="46.0" width="74.0" height="40.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli — 80 lines</title></rect>
+<rect x="356.0" y="70.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.usage" data-kind="function" class="blk"><title>usage — function, 7 lines</title></rect>
+<rect x="356.0" y="75.0" width="74.0" height="10.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.main" data-kind="function" class="blk"><title>main — function, 21 lines</title></rect>
 <rect x="438.0" y="46.0" width="74.0" height="14.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.ops — 28 lines</title></rect>
 <rect x="520.0" y="46.0" width="74.0" height="14.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.notebook — 15 lines</title></rect>
 <rect x="602.0" y="46.0" width="74.0" height="14.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters — 12 lines</title></rect>
 <rect x="684.0" y="46.0" width="74.0" height="14.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.lab — 11 lines</title></rect>
 <rect x="766.0" y="46.0" width="74.0" height="14.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.__main__ — 9 lines</title></rect>
-<rect x="28.0" y="1248.0" width="74.0" height="14.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.ir — 7 lines</title></rect>
-<rect x="110.0" y="1248.0" width="74.0" height="14.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors — 2 lines</title></rect>
-<rect x="210.0" y="1248.0" width="74.0" height="126.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.emit — 253 lines</title></rect>
-<rect x="210.0" y="1260.0" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit._parser" data-kind="function" class="blk"><title>_parser — function, 7 lines</title></rect>
-<rect x="210.0" y="1264.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit._size" data-kind="function" class="blk"><title>_size — function, 3 lines</title></rect>
-<rect x="210.0" y="1267.0" width="74.0" height="8.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.auto" data-kind="function" class="blk"><title>auto — function, 16 lines</title></rect>
-<rect x="210.0" y="1276.0" width="74.0" height="19.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.dot" data-kind="function" class="blk"><title>dot — function, 38 lines</title></rect>
-<rect x="210.0" y="1296.0" width="74.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.erd" data-kind="function" class="blk"><title>erd — function, 11 lines</title></rect>
-<rect x="210.0" y="1302.5" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.index" data-kind="function" class="blk"><title>index — function, 14 lines</title></rect>
-<rect x="210.0" y="1310.5" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.minimap" data-kind="function" class="blk"><title>minimap — function, 14 lines</title></rect>
-<rect x="210.0" y="1318.5" width="74.0" height="20.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.notebook" data-kind="function" class="blk"><title>notebook — function, 41 lines</title></rect>
-<rect x="210.0" y="1340.0" width="74.0" height="15.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.site" data-kind="function" class="blk"><title>site — function, 31 lines</title></rect>
-<rect x="210.0" y="1356.5" width="74.0" height="11.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.explore" data-kind="function" class="blk"><title>explore — function, 22 lines</title></rect>
-<rect x="210.0" y="1370.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.main" data-kind="function" class="blk"><title>main — function, 7 lines</title></rect>
-<rect x="292.0" y="1248.0" width="74.0" height="59.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.extract — 119 lines</title></rect>
-<rect x="292.0" y="1257.5" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract._parser" data-kind="function" class="blk"><title>_parser — function, 5 lines</title></rect>
-<rect x="292.0" y="1261.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract._counts" data-kind="function" class="blk"><title>_counts — function, 3 lines</title></rect>
-<rect x="292.0" y="1263.5" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.python" data-kind="function" class="blk"><title>python — function, 15 lines</title></rect>
-<rect x="292.0" y="1272.0" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.code" data-kind="function" class="blk"><title>code — function, 14 lines</title></rect>
-<rect x="292.0" y="1280.0" width="74.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.db" data-kind="function" class="blk"><title>db — function, 11 lines</title></rect>
-<rect x="292.0" y="1286.5" width="74.0" height="6.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.openapi" data-kind="function" class="blk"><title>openapi — function, 12 lines</title></rect>
-<rect x="292.0" y="1293.5" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.usage" data-kind="function" class="blk"><title>usage — function, 15 lines</title></rect>
-<rect x="292.0" y="1303.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.main" data-kind="function" class="blk"><title>main — function, 7 lines</title></rect>
-<rect x="374.0" y="1248.0" width="74.0" height="45.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.view — 90 lines</title></rect>
-<rect x="374.0" y="1255.0" width="74.0" height="37.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.view.main" data-kind="function" class="blk"><title>main — function, 75 lines</title></rect>
-<rect x="456.0" y="1248.0" width="74.0" height="40.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.common — 80 lines</title></rect>
-<rect x="456.0" y="1258.0" width="74.0" height="2.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.cli.common.Abort" data-kind="class" class="blk"><title>Abort — class, 2 lines</title></rect>
-<rect x="456.0" y="1260.0" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.read_json" data-kind="function" class="blk"><title>read_json — function, 5 lines</title></rect>
-<rect x="456.0" y="1263.5" width="74.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.read_ir" data-kind="function" class="blk"><title>read_ir — function, 11 lines</title></rect>
-<rect x="456.0" y="1270.0" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.load_style" data-kind="function" class="blk"><title>load_style — function, 7 lines</title></rect>
-<rect x="456.0" y="1274.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.style_args" data-kind="function" class="blk"><title>style_args — function, 3 lines</title></rect>
-<rect x="456.0" y="1277.0" width="74.0" height="8.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.emit" data-kind="function" class="blk"><title>emit — function, 16 lines</title></rect>
-<rect x="456.0" y="1286.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.dump_ir" data-kind="function" class="blk"><title>dump_ir — function, 3 lines</title></rect>
-<rect x="538.0" y="1248.0" width="74.0" height="40.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.run — 80 lines</title></rect>
-<rect x="538.0" y="1258.0" width="74.0" height="29.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.run.main" data-kind="function" class="blk"><title>main — function, 59 lines</title></rect>
-<rect x="620.0" y="1248.0" width="74.0" height="37.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.book — 74 lines</title></rect>
-<rect x="620.0" y="1258.5" width="74.0" height="26.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.book.main" data-kind="function" class="blk"><title>main — function, 52 lines</title></rect>
-<rect x="702.0" y="1248.0" width="74.0" height="25.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.check — 51 lines</title></rect>
-<rect x="702.0" y="1258.0" width="74.0" height="15.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.check.main" data-kind="function" class="blk"><title>main — function, 30 lines</title></rect>
-<rect x="784.0" y="1248.0" width="74.0" height="16.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.validate — 33 lines</title></rect>
-<rect x="784.0" y="1255.0" width="74.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.validate.main" data-kind="function" class="blk"><title>main — function, 18 lines</title></rect>
-<rect x="28.0" y="1412.5" width="74.0" height="247.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.site — 494 lines</title></rect>
-<rect x="28.0" y="1548.5" width="74.0" height="27.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site._ledger" data-kind="function" class="blk"><title>_ledger — function, 54 lines</title></rect>
-<rect x="28.0" y="1576.5" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site._slots" data-kind="function" class="blk"><title>_slots — function, 13 lines</title></rect>
-<rect x="28.0" y="1584.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site._fill" data-kind="function" class="blk"><title>_fill — function, 4 lines</title></rect>
-<rect x="28.0" y="1587.0" width="74.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site._sidebar" data-kind="function" class="blk"><title>_sidebar — function, 17 lines</title></rect>
-<rect x="28.0" y="1596.5" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site._sections" data-kind="function" class="blk"><title>_sections — function, 15 lines</title></rect>
-<rect x="28.0" y="1605.0" width="74.0" height="48.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site.emit" data-kind="function" class="blk"><title>emit — function, 96 lines</title></rect>
-<rect x="28.0" y="1654.0" width="74.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site.write" data-kind="function" class="blk"><title>write — function, 10 lines</title></rect>
-<rect x="110.0" y="1412.5" width="74.0" height="158.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.explore — 316 lines</title></rect>
-<rect x="110.0" y="1432.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.explore._is_schema" data-kind="function" class="blk"><title>_is_schema — function, 4 lines</title></rect>
-<rect x="110.0" y="1435.0" width="74.0" height="24.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.explore._neighbourhood_svgs" data-kind="function" class="blk"><title>_neighbourhood_svgs — function, 48 lines</title></rect>
-<rect x="117.0" y="1441.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.explore._neighbourhood_svgs.render_one" data-kind="function" class="blk"><title>render_one — function, 2 lines</title></rect>
-<rect x="117.0" y="1445.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.explore._neighbourhood_svgs.render_one#L66" data-kind="function" class="blk"><title>render_one — function, 2 lines</title></rect>
-<rect x="110.0" y="1460.0" width="74.0" height="13.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.explore._facts" data-kind="function" class="blk"><title>_facts — function, 27 lines</title></rect>
-<rect x="110.0" y="1474.5" width="74.0" height="86.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.explore.emit" data-kind="function" class="blk"><title>emit — function, 172 lines</title></rect>
-<rect x="110.0" y="1561.5" width="74.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.explore.write" data-kind="function" class="blk"><title>write — function, 17 lines</title></rect>
-<rect x="192.0" y="1412.5" width="74.0" height="146.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.dot — 292 lines</title></rect>
-<rect x="192.0" y="1431.0" width="74.0" height="2.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.emitters.dot.RenderError" data-kind="class" class="blk"><title>RenderError — class, 2 lines</title></rect>
-<rect x="192.0" y="1433.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._esc" data-kind="function" class="blk"><title>_esc — function, 2 lines</title></rect>
-<rect x="192.0" y="1435.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._attrs" data-kind="function" class="blk"><title>_attrs — function, 3 lines</title></rect>
-<rect x="192.0" y="1437.5" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._style_words" data-kind="function" class="blk"><title>_style_words — function, 9 lines</title></rect>
-<rect x="192.0" y="1443.0" width="74.0" height="12.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._node_attrs" data-kind="function" class="blk"><title>_node_attrs — function, 24 lines</title></rect>
-<rect x="192.0" y="1456.0" width="74.0" height="52.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot.emit" data-kind="function" class="blk"><title>emit — function, 105 lines</title></rect>
-<rect x="199.0" y="1469.5" width="60.0" height="14.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.dot.emit.write" data-kind="function" class="blk"><title>write — function, 29 lines</title></rect>
-<rect x="192.0" y="1509.5" width="74.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._within" data-kind="function" class="blk"><title>_within — function, 8 lines</title></rect>
-<rect x="192.0" y="1514.5" width="74.0" height="20.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._endpoints" data-kind="function" class="blk"><title>_endpoints — function, 41 lines</title></rect>
-<rect x="199.0" y="1519.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.dot._endpoints.walk" data-kind="function" class="blk"><title>walk — function, 4 lines</title></rect>
-<rect x="199.0" y="1523.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.dot._endpoints.collapsed" data-kind="function" class="blk"><title>collapsed — function, 2 lines</title></rect>
-<rect x="199.0" y="1525.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.dot._endpoints.first_leaf" data-kind="function" class="blk"><title>first_leaf — function, 4 lines</title></rect>
-<rect x="192.0" y="1536.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._safe" data-kind="function" class="blk"><title>_safe — function, 2 lines</title></rect>
-<rect x="192.0" y="1538.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._q" data-kind="function" class="blk"><title>_q — function, 2 lines</title></rect>
-<rect x="192.0" y="1541.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot.have_graphviz" data-kind="function" class="blk"><title>have_graphviz — function, 2 lines</title></rect>
-<rect x="192.0" y="1543.5" width="74.0" height="14.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot.render" data-kind="function" class="blk"><title>render — function, 29 lines</title></rect>
-<rect x="274.0" y="1412.5" width="74.0" height="139.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.notebook — 279 lines</title></rect>
-<rect x="274.0" y="1433.5" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._cell" data-kind="function" class="blk"><title>_cell — function, 13 lines</title></rect>
-<rect x="274.0" y="1441.0" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._example" data-kind="function" class="blk"><title>_example — function, 26 lines</title></rect>
-<rect x="274.0" y="1474.5" width="74.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._params_cell" data-kind="function" class="blk"><title>_params_cell — function, 18 lines</title></rect>
-<rect x="274.0" y="1484.5" width="74.0" height="20.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._call_cell" data-kind="function" class="blk"><title>_call_cell — function, 40 lines</title></rect>
-<rect x="274.0" y="1505.5" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._call_md" data-kind="function" class="blk"><title>_call_md — function, 26 lines</title></rect>
-<rect x="274.0" y="1519.5" width="74.0" height="26.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook.build" data-kind="function" class="blk"><title>build — function, 52 lines</title></rect>
-<rect x="274.0" y="1546.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook.emit" data-kind="function" class="blk"><title>emit — function, 3 lines</title></rect>
-<rect x="274.0" y="1549.0" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook.write" data-kind="function" class="blk"><title>write — function, 5 lines</title></rect>
-<rect x="356.0" y="1412.5" width="74.0" height="139.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.minimap — 278 lines</title></rect>
-<rect x="356.0" y="1444.0" width="74.0" height="28.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.minimap._files" data-kind="function" class="blk"><title>_files — function, 57 lines</title></rect>
-<rect x="363.0" y="1448.0" width="60.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.minimap._files.declared" data-kind="function" class="blk"><title>declared — function, 18 lines</title></rect>
-<rect x="363.0" y="1457.5" width="60.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.minimap._files.build" data-kind="function" class="blk"><title>build — function, 11 lines</title></rect>
-<rect x="356.0" y="1473.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.minimap._bands" data-kind="function" class="blk"><title>_bands — function, 7 lines</title></rect>
-<rect x="356.0" y="1478.0" width="74.0" height="9.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.minimap._blocks" data-kind="function" class="blk"><title>_blocks — function, 19 lines</title></rect>
-<rect x="356.0" y="1488.5" width="74.0" height="60.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.minimap.emit" data-kind="function" class="blk"><title>emit — function, 120 lines</title></rect>
-<rect x="356.0" y="1549.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.minimap.marks_to_labels" data-kind="function" class="blk"><title>marks_to_labels — function, 3 lines</title></rect>
-<rect x="438.0" y="1412.5" width="74.0" height="130.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.erd — 260 lines</title></rect>
-<rect x="438.0" y="1439.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd._truncate" data-kind="function" class="blk"><title>_truncate — function, 3 lines</title></rect>
-<rect x="438.0" y="1442.0" width="74.0" height="10.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd._tables" data-kind="function" class="blk"><title>_tables — function, 20 lines</title></rect>
-<rect x="438.0" y="1453.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd._card_height" data-kind="function" class="blk"><title>_card_height — function, 3 lines</title></rect>
-<rect x="438.0" y="1455.5" width="74.0" height="10.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd.layout" data-kind="function" class="blk"><title>layout — function, 20 lines</title></rect>
-<rect x="438.0" y="1466.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd._field_y" data-kind="function" class="blk"><title>_field_y — function, 3 lines</title></rect>
-<rect x="438.0" y="1469.0" width="74.0" height="73.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd.emit" data-kind="function" class="blk"><title>emit — function, 146 lines</title></rect>
-<rect x="520.0" y="1412.5" width="74.0" height="82.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.index — 164 lines</title></rect>
-<rect x="520.0" y="1429.5" width="74.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.index._tree" data-kind="function" class="blk"><title>_tree — function, 8 lines</title></rect>
-<rect x="520.0" y="1434.5" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.index._anchor" data-kind="function" class="blk"><title>_anchor — function, 5 lines</title></rect>
-<rect x="520.0" y="1438.0" width="74.0" height="42.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.index.to_markdown" data-kind="function" class="blk"><title>to_markdown — function, 84 lines</title></rect>
-<rect x="527.0" y="1449.5" width="60.0" height="13.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.index.to_markdown.walk" data-kind="function" class="blk"><title>walk — function, 27 lines</title></rect>
-<rect x="520.0" y="1481.0" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.index.to_sidebar" data-kind="function" class="blk"><title>to_sidebar — function, 26 lines</title></rect>
-<rect x="527.0" y="1484.5" width="60.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.index.to_sidebar.build" data-kind="function" class="blk"><title>build — function, 13 lines</title></rect>
-<rect x="602.0" y="1412.5" width="74.0" height="32.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.auto — 64 lines</title></rect>
-<rect x="602.0" y="1426.0" width="74.0" height="18.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.auto.draw" data-kind="function" class="blk"><title>draw — function, 36 lines</title></rect>
-<rect x="702.0" y="1412.5" width="74.0" height="141.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.code — 282 lines</title></rect>
-<rect x="702.0" y="1460.0" width="74.0" height="2.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.extractors.code.MissingParser" data-kind="class" class="blk"><title>MissingParser — class, 2 lines</title></rect>
-<rect x="702.0" y="1462.0" width="74.0" height="10.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code._parser" data-kind="function" class="blk"><title>_parser — function, 21 lines</title></rect>
-<rect x="702.0" y="1473.5" width="74.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code._name" data-kind="function" class="blk"><title>_name — function, 10 lines</title></rect>
-<rect x="702.0" y="1479.5" width="74.0" height="17.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code._walk" data-kind="function" class="blk"><title>_walk — function, 34 lines</title></rect>
-<rect x="702.0" y="1497.5" width="74.0" height="13.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code.extract_file" data-kind="function" class="blk"><title>extract_file — function, 27 lines</title></rect>
-<rect x="702.0" y="1512.0" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code._count_errors" data-kind="function" class="blk"><title>_count_errors — function, 5 lines</title></rect>
-<rect x="702.0" y="1515.5" width="74.0" height="37.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code.extract" data-kind="function" class="blk"><title>extract — function, 75 lines</title></rect>
-<rect x="784.0" y="1412.5" width="74.0" height="134.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.usage — 269 lines</title></rect>
-<rect x="784.0" y="1444.5" width="74.0" height="13.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.usage._template" data-kind="function" class="blk"><title>_template — function, 27 lines</title></rect>
-<rect x="784.0" y="1459.0" width="74.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.usage._body" data-kind="function" class="blk"><title>_body — function, 10 lines</title></rect>
-<rect x="784.0" y="1465.0" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.usage._shape" data-kind="function" class="blk"><title>_shape — function, 15 lines</title></rect>
-<rect x="784.0" y="1473.5" width="74.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.usage._graphql" data-kind="function" class="blk"><title>_graphql — function, 11 lines</title></rect>
-<rect x="784.0" y="1480.0" width="74.0" height="66.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.usage.extract" data-kind="function" class="blk"><title>extract — function, 133 lines</title></rect>
-<rect x="28.0" y="1697.5" width="74.0" height="95.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.openapi — 191 lines</title></rect>
-<rect x="28.0" y="1713.0" width="74.0" height="14.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.openapi._modelgen" data-kind="function" class="blk"><title>_modelgen — function, 28 lines</title></rect>
-<rect x="28.0" y="1728.0" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.openapi._type_name" data-kind="function" class="blk"><title>_type_name — function, 6 lines</title></rect>
-<rect x="28.0" y="1732.0" width="74.0" height="21.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.openapi._refs" data-kind="function" class="blk"><title>_refs — function, 43 lines</title></rect>
-<rect x="28.0" y="1754.5" width="74.0" height="38.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.openapi.extract" data-kind="function" class="blk"><title>extract — function, 76 lines</title></rect>
-<rect x="110.0" y="1697.5" width="74.0" height="80.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.db — 161 lines</title></rect>
-<rect x="110.0" y="1717.0" width="74.0" height="41.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.db.from_schema_dict" data-kind="function" class="blk"><title>from_schema_dict — function, 82 lines</title></rect>
-<rect x="110.0" y="1759.0" width="74.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.db._relation" data-kind="function" class="blk"><title>_relation — function, 10 lines</title></rect>
-<rect x="110.0" y="1765.0" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.db._plain_type" data-kind="function" class="blk"><title>_plain_type — function, 6 lines</title></rect>
-<rect x="110.0" y="1769.0" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.db._dedupe" data-kind="function" class="blk"><title>_dedupe — function, 9 lines</title></rect>
-<rect x="110.0" y="1774.5" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.db.extract" data-kind="function" class="blk"><title>extract — function, 6 lines</title></rect>
-<rect x="192.0" y="1697.5" width="74.0" height="18.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.python — 37 lines</title></rect>
-<rect x="192.0" y="1707.0" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.extract" data-kind="function" class="blk"><title>extract — function, 14 lines</title></rect>
-<rect x="292.0" y="1697.5" width="74.0" height="190.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.book.build — 381 lines</title></rect>
-<rect x="292.0" y="1735.0" width="74.0" height="13.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.build.extract" data-kind="function" class="blk"><title>extract — function, 27 lines</title></rect>
-<rect x="292.0" y="1749.5" width="74.0" height="34.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.build.spec_from" data-kind="function" class="blk"><title>spec_from — function, 68 lines</title></rect>
-<rect x="292.0" y="1784.5" width="74.0" height="22.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.build._load_cell" data-kind="function" class="blk"><title>_load_cell — function, 44 lines</title></rect>
-<rect x="292.0" y="1811.0" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.build.clear" data-kind="function" class="blk"><title>clear — function, 26 lines</title></rect>
-<rect x="292.0" y="1825.0" width="74.0" height="62.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.build.run" data-kind="function" class="blk"><title>run — function, 125 lines</title></rect>
-<rect x="299.0" y="1831.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.build.run.say" data-kind="function" class="blk"><title>say — function, 3 lines</title></rect>
-<rect x="374.0" y="1697.5" width="74.0" height="164.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.book.config — 328 lines</title></rect>
-<rect x="374.0" y="1738.0" width="74.0" height="3.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.config.ConfigError" data-kind="class" class="blk"><title>ConfigError — class, 6 lines</title></rect>
-<rect x="381.0" y="1739.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.config.ConfigError.__init__" data-kind="function" class="blk"><title>__init__ — function, 3 lines</title></rect>
-<rect x="374.0" y="1742.5" width="74.0" height="7.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.config.Entry" data-kind="class" class="blk"><title>Entry — class, 14 lines</title></rect>
-<rect x="381.0" y="1748.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.config.Entry.line" data-kind="function" class="blk"><title>line — function, 2 lines</title></rect>
-<rect x="374.0" y="1751.0" width="74.0" height="8.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.config.RunFile" data-kind="class" class="blk"><title>RunFile — class, 17 lines</title></rect>
-<rect x="381.0" y="1753.5" width="60.0" height="6.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.config.RunFile.select" data-kind="function" class="blk"><title>select — function, 12 lines</title></rect>
-<rect x="374.0" y="1760.5" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config._path" data-kind="function" class="blk"><title>_path — function, 6 lines</title></rect>
-<rect x="374.0" y="1764.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config._within" data-kind="function" class="blk"><title>_within — function, 3 lines</title></rect>
-<rect x="374.0" y="1767.0" width="74.0" height="65.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config.load" data-kind="function" class="blk"><title>load — function, 130 lines</title></rect>
-<rect x="381.0" y="1799.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.config.load.pick" data-kind="function" class="blk"><title>pick — function, 3 lines</title></rect>
-<rect x="374.0" y="1833.0" width="74.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config.apply_reference" data-kind="function" class="blk"><title>apply_reference — function, 11 lines</title></rect>
-<rect x="374.0" y="1839.5" width="74.0" height="21.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config.run" data-kind="function" class="blk"><title>run — function, 43 lines</title></rect>
-<rect x="456.0" y="1697.5" width="74.0" height="137.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.book.checks — 275 lines</title></rect>
-<rect x="456.0" y="1728.0" width="74.0" height="13.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.checks.Loaded" data-kind="class" class="blk"><title>Loaded — class, 26 lines</title></rect>
-<rect x="463.0" y="1729.5" width="60.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Loaded.__init__" data-kind="function" class="blk"><title>__init__ — function, 15 lines</title></rect>
-<rect x="463.0" y="1738.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Loaded.larder" data-kind="function" class="blk"><title>larder — function, 2 lines</title></rect>
-<rect x="463.0" y="1740.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Loaded.measure" data-kind="function" class="blk"><title>measure — function, 2 lines</title></rect>
-<rect x="456.0" y="1742.0" width="74.0" height="18.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.checks.Report" data-kind="class" class="blk"><title>Report — class, 37 lines</title></rect>
-<rect x="463.0" y="1743.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Report.__init__" data-kind="function" class="blk"><title>__init__ — function, 2 lines</title></rect>
-<rect x="463.0" y="1745.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Report.note" data-kind="function" class="blk"><title>note — function, 2 lines</title></rect>
-<rect x="463.0" y="1746.5" width="60.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Report.check" data-kind="function" class="blk"><title>check — function, 8 lines</title></rect>
-<rect x="463.0" y="1751.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Report.skip" data-kind="function" class="blk"><title>skip — function, 3 lines</title></rect>
-<rect x="463.0" y="1753.0" width="60.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Report.total" data-kind="function" class="blk"><title>total — function, 15 lines</title></rect>
-<rect x="456.0" y="1761.5" width="74.0" height="41.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.checks.generated" data-kind="function" class="blk"><title>generated — function, 83 lines</title></rect>
-<rect x="456.0" y="1804.0" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.checks.custom" data-kind="function" class="blk"><title>custom — function, 26 lines</title></rect>
-<rect x="456.0" y="1818.0" width="74.0" height="16.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.checks._run_cells" data-kind="function" class="blk"><title>_run_cells — function, 33 lines</title></rect>
-<rect x="538.0" y="1697.5" width="74.0" height="98.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.book.larder — 196 lines</title></rect>
-<rect x="538.0" y="1729.0" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.larder._count" data-kind="function" class="blk"><title>_count — function, 13 lines</title></rect>
-<rect x="538.0" y="1736.5" width="74.0" height="16.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.larder.redact" data-kind="function" class="blk"><title>redact — function, 32 lines</title></rect>
-<rect x="538.0" y="1754.0" width="74.0" height="38.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.larder.Larder" data-kind="class" class="blk"><title>Larder — class, 77 lines</title></rect>
-<rect x="545.0" y="1761.0" width="60.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.__post_init__" data-kind="function" class="blk"><title>__post_init__ — function, 7 lines</title></rect>
-<rect x="545.0" y="1765.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.read" data-kind="function" class="blk"><title>read — function, 3 lines</title></rect>
-<rect x="545.0" y="1767.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.fail" data-kind="function" class="blk"><title>fail — function, 3 lines</title></rect>
-<rect x="545.0" y="1769.5" width="60.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.to_dict" data-kind="function" class="blk"><title>to_dict — function, 13 lines</title></rect>
-<rect x="545.0" y="1777.0" width="60.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.from_dict" data-kind="function" class="blk"><title>from_dict — function, 10 lines</title></rect>
-<rect x="545.0" y="1782.5" width="60.0" height="10.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.line" data-kind="function" class="blk"><title>line — function, 20 lines</title></rect>
-<rect x="538.0" y="1793.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.larder.of" data-kind="function" class="blk"><title>of — function, 3 lines</title></rect>
-<rect x="638.0" y="1697.5" width="74.0" height="118.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.python.collect — 236 lines</title></rect>
-<rect x="638.0" y="1714.0" width="74.0" height="5.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect.Definition" data-kind="class" class="blk"><title>Definition — class, 10 lines</title></rect>
-<rect x="638.0" y="1720.5" width="74.0" height="6.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect.Module" data-kind="class" class="blk"><title>Module — class, 12 lines</title></rect>
-<rect x="638.0" y="1727.5" width="74.0" height="33.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect._Collector" data-kind="class" class="blk"><title>_Collector — class, 67 lines</title></rect>
-<rect x="645.0" y="1729.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector.__init__" data-kind="function" class="blk"><title>__init__ — function, 3 lines</title></rect>
-<rect x="645.0" y="1732.0" width="60.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector._define" data-kind="function" class="blk"><title>_define — function, 17 lines</title></rect>
-<rect x="645.0" y="1741.0" width="60.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector.visit_ClassDef" data-kind="function" class="blk"><title>visit_ClassDef — function, 5 lines</title></rect>
-<rect x="645.0" y="1744.0" width="60.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector.visit_FunctionDef" data-kind="function" class="blk"><title>visit_FunctionDef — function, 5 lines</title></rect>
-<rect x="645.0" y="1749.5" width="60.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector.visit_Import" data-kind="function" class="blk"><title>visit_Import — function, 8 lines</title></rect>
-<rect x="645.0" y="1754.0" width="60.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector.visit_ImportFrom" data-kind="function" class="blk"><title>visit_ImportFrom — function, 14 lines</title></rect>
-<rect x="638.0" y="1762.0" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect._first_line" data-kind="function" class="blk"><title>_first_line — function, 5 lines</title></rect>
-<rect x="638.0" y="1765.5" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect._name_of" data-kind="function" class="blk"><title>_name_of — function, 15 lines</title></rect>
-<rect x="638.0" y="1774.0" width="74.0" height="8.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect._resolve_relative" data-kind="function" class="blk"><title>_resolve_relative — function, 16 lines</title></rect>
-<rect x="638.0" y="1783.0" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect.module_name" data-kind="function" class="blk"><title>module_name — function, 26 lines</title></rect>
-<rect x="638.0" y="1797.0" width="74.0" height="10.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect.collect_file" data-kind="function" class="blk"><title>collect_file — function, 21 lines</title></rect>
-<rect x="638.0" y="1808.5" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect.collect" data-kind="function" class="blk"><title>collect — function, 13 lines</title></rect>
-<rect x="720.0" y="1697.5" width="74.0" height="92.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.python.resolve — 184 lines</title></rect>
-<rect x="720.0" y="1711.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.resolve._id_for" data-kind="function" class="blk"><title>_id_for — function, 2 lines</title></rect>
-<rect x="720.0" y="1713.5" width="74.0" height="16.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.resolve._resolve" data-kind="function" class="blk"><title>_resolve — function, 32 lines</title></rect>
-<rect x="720.0" y="1730.5" width="74.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.resolve.larder_of" data-kind="function" class="blk"><title>larder_of — function, 17 lines</title></rect>
-<rect x="720.0" y="1740.0" width="74.0" height="49.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.resolve.to_ir" data-kind="function" class="blk"><title>to_ir — function, 98 lines</title></rect>
-<rect x="727.0" y="1769.5" width="60.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.resolve.to_ir._point_at" data-kind="function" class="blk"><title>_point_at — function, 9 lines</title></rect>
-<rect x="28.0" y="1926.0" width="74.0" height="139.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.ir.validate — 278 lines</title></rect>
-<rect x="28.0" y="1947.0" width="74.0" height="2.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.ir.validate.IRError" data-kind="class" class="blk"><title>IRError — class, 2 lines</title></rect>
-<rect x="28.0" y="1949.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate._schema" data-kind="function" class="blk"><title>_schema — function, 2 lines</title></rect>
-<rect x="28.0" y="1951.0" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate._props" data-kind="function" class="blk"><title>_props — function, 5 lines</title></rect>
-<rect x="28.0" y="1954.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate._fields" data-kind="function" class="blk"><title>_fields — function, 4 lines</title></rect>
-<rect x="28.0" y="1957.5" width="74.0" height="54.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate.check" data-kind="function" class="blk"><title>check — function, 108 lines</title></rect>
-<rect x="28.0" y="2019.0" width="74.0" height="29.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate._check_larder" data-kind="function" class="blk"><title>_check_larder — function, 58 lines</title></rect>
-<rect x="28.0" y="2049.0" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate.validate" data-kind="function" class="blk"><title>validate — function, 6 lines</title></rect>
-<rect x="28.0" y="2053.0" width="74.0" height="11.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate.check_model_matches_schema" data-kind="function" class="blk"><title>check_model_matches_schema — function, 23 lines</title></rect>
-<rect x="110.0" y="1926.0" width="74.0" height="82.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.ir.model — 165 lines</title></rect>
-<rect x="110.0" y="1942.5" width="74.0" height="19.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.ir.model.Meta" data-kind="class" class="blk"><title>Meta — class, 38 lines</title></rect>
-<rect x="117.0" y="1952.5" width="60.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Meta.to_dict" data-kind="function" class="blk"><title>to_dict — function, 18 lines</title></rect>
-<rect x="110.0" y="1963.0" width="74.0" height="10.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.ir.model.Node" data-kind="class" class="blk"><title>Node — class, 21 lines</title></rect>
-<rect x="117.0" y="1967.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Node.__post_init__" data-kind="function" class="blk"><title>__post_init__ — function, 3 lines</title></rect>
-<rect x="117.0" y="1969.5" width="60.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Node.to_dict" data-kind="function" class="blk"><title>to_dict — function, 8 lines</title></rect>
-<rect x="110.0" y="1975.0" width="74.0" height="7.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.ir.model.Edge" data-kind="class" class="blk"><title>Edge — class, 15 lines</title></rect>
-<rect x="117.0" y="1979.0" width="60.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Edge.to_dict" data-kind="function" class="blk"><title>to_dict — function, 7 lines</title></rect>
-<rect x="110.0" y="1984.0" width="74.0" height="24.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.ir.model.Graph" data-kind="class" class="blk"><title>Graph — class, 48 lines</title></rect>
-<rect x="117.0" y="1988.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Graph.node" data-kind="function" class="blk"><title>node — function, 4 lines</title></rect>
-<rect x="117.0" y="1991.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Graph.edge" data-kind="function" class="blk"><title>edge — function, 4 lines</title></rect>
-<rect x="117.0" y="1993.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Graph.has" data-kind="function" class="blk"><title>has — function, 2 lines</title></rect>
-<rect x="117.0" y="1996.0" width="60.0" height="8.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Graph.to_dict" data-kind="function" class="blk"><title>to_dict — function, 16 lines</title></rect>
-<rect x="117.0" y="2005.0" width="60.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Graph.from_dict" data-kind="function" class="blk"><title>from_dict — function, 6 lines</title></rect>
-<rect x="210.0" y="1926.0" width="74.0" height="111.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.style.extract — 222 lines</title></rect>
-<rect x="210.0" y="1956.5" width="74.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract._values_from" data-kind="function" class="blk"><title>_values_from — function, 17 lines</title></rect>
-<rect x="210.0" y="1966.0" width="74.0" height="22.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract._normalise" data-kind="function" class="blk"><title>_normalise — function, 45 lines</title></rect>
-<rect x="210.0" y="1989.5" width="74.0" height="12.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract._svg_files" data-kind="function" class="blk"><title>_svg_files — function, 25 lines</title></rect>
-<rect x="210.0" y="2003.0" width="74.0" height="21.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract.harvest" data-kind="function" class="blk"><title>harvest — function, 43 lines</title></rect>
-<rect x="210.0" y="2025.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract.write" data-kind="function" class="blk"><title>write — function, 7 lines</title></rect>
-<rect x="210.0" y="2030.0" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract.summarise" data-kind="function" class="blk"><title>summarise — function, 13 lines</title></rect>
-<rect x="292.0" y="1926.0" width="74.0" height="105.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.style.tokens — 211 lines</title></rect>
-<rect x="292.0" y="1954.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens._top" data-kind="function" class="blk"><title>_top — function, 2 lines</title></rect>
-<rect x="292.0" y="1956.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens._mode" data-kind="function" class="blk"><title>_mode — function, 3 lines</title></rect>
-<rect x="292.0" y="1958.5" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens._luminance" data-kind="function" class="blk"><title>_luminance — function, 6 lines</title></rect>
-<rect x="292.0" y="1962.5" width="74.0" height="50.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens.derive" data-kind="function" class="blk"><title>derive — function, 101 lines</title></rect>
-<rect x="299.0" y="1984.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.style.tokens.derive.accent" data-kind="function" class="blk"><title>accent — function, 2 lines</title></rect>
-<rect x="292.0" y="2014.0" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens.geometry" data-kind="function" class="blk"><title>geometry — function, 14 lines</title></rect>
-<rect x="292.0" y="2022.0" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens.write" data-kind="function" class="blk"><title>write — function, 7 lines</title></rect>
-<rect x="292.0" y="2026.5" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens.from_folder" data-kind="function" class="blk"><title>from_folder — function, 9 lines</title></rect>
-<rect x="392.0" y="1926.0" width="74.0" height="14.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen — 2 lines</title></rect>
-<rect x="492.0" y="1926.0" width="74.0" height="75.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.lab.pg_probe — 150 lines</title></rect>
-<rect x="492.0" y="1961.5" width="74.0" height="15.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.lab.pg_probe.probe" data-kind="function" class="blk"><title>probe — function, 30 lines</title></rect>
-<rect x="492.0" y="1983.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.lab.pg_probe._simplify" data-kind="function" class="blk"><title>_simplify — function, 3 lines</title></rect>
-<rect x="492.0" y="1986.0" width="74.0" height="12.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.lab.pg_probe.main" data-kind="function" class="blk"><title>main — function, 25 lines</title></rect>
-<rect x="592.0" y="1926.0" width="74.0" height="132.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.notebook.spec — 264 lines</title></rect>
-<rect x="592.0" y="1954.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec._step" data-kind="function" class="blk"><title>_step — function, 4 lines</title></rect>
-<rect x="592.0" y="1957.0" width="74.0" height="54.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec.from_ir" data-kind="function" class="blk"><title>from_ir — function, 108 lines</title></rect>
-<rect x="599.0" y="1964.0" width="60.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.notebook.spec.from_ir._order" data-kind="function" class="blk"><title>_order — function, 5 lines</title></rect>
-<rect x="592.0" y="2012.0" width="74.0" height="10.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec.scaffold" data-kind="function" class="blk"><title>scaffold — function, 20 lines</title></rect>
-<rect x="592.0" y="2023.0" width="74.0" height="29.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec.merge" data-kind="function" class="blk"><title>merge — function, 58 lines</title></rect>
-<rect x="592.0" y="2053.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec.load" data-kind="function" class="blk"><title>load — function, 2 lines</title></rect>
-<rect x="592.0" y="2055.0" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec.dump" data-kind="function" class="blk"><title>dump — function, 5 lines</title></rect>
-<rect x="692.0" y="1926.0" width="74.0" height="242.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.ops.filter — 485 lines</title></rect>
-<rect x="692.0" y="1944.0" width="74.0" height="28.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter._rebuild" data-kind="function" class="blk"><title>_rebuild — function, 57 lines</title></rect>
-<rect x="699.0" y="1948.5" width="60.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ops.filter._rebuild.surviving_parent" data-kind="function" class="blk"><title>surviving_parent — function, 5 lines</title></rect>
-<rect x="699.0" y="1955.5" width="60.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ops.filter._rebuild.lift" data-kind="function" class="blk"><title>lift — function, 6 lines</title></rect>
-<rect x="692.0" y="1973.5" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.drop_kinds" data-kind="function" class="blk"><title>drop_kinds — function, 14 lines</title></rect>
-<rect x="692.0" y="1981.5" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.only_kinds" data-kind="function" class="blk"><title>only_kinds — function, 14 lines</title></rect>
-<rect x="692.0" y="1989.5" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.drop_stdlib" data-kind="function" class="blk"><title>drop_stdlib — function, 13 lines</title></rect>
-<rect x="692.0" y="1997.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.drop_external" data-kind="function" class="blk"><title>drop_external — function, 3 lines</title></rect>
-<rect x="692.0" y="1999.5" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.subtree" data-kind="function" class="blk"><title>subtree — function, 13 lines</title></rect>
-<rect x="692.0" y="2007.0" width="74.0" height="22.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.neighbourhood" data-kind="function" class="blk"><title>neighbourhood — function, 45 lines</title></rect>
-<rect x="692.0" y="2030.5" width="74.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.collapse_to_depth" data-kind="function" class="blk"><title>collapse_to_depth — function, 18 lines</title></rect>
-<rect x="699.0" y="2035.5" width="60.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ops.filter.collapse_to_depth.level" data-kind="function" class="blk"><title>level — function, 6 lines</title></rect>
-<rect x="692.0" y="2040.5" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.drop_builtins" data-kind="function" class="blk"><title>drop_builtins — function, 14 lines</title></rect>
-<rect x="692.0" y="2048.5" width="74.0" height="17.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.overview" data-kind="function" class="blk"><title>overview — function, 35 lines</title></rect>
-<rect x="692.0" y="2067.0" width="74.0" height="36.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.shape" data-kind="function" class="blk"><title>shape — function, 72 lines</title></rect>
-<rect x="699.0" y="2091.0" width="60.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ops.filter.shape.rank_of" data-kind="function" class="blk"><title>rank_of — function, 9 lines</title></rect>
-<rect x="692.0" y="2104.0" width="74.0" height="12.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.split" data-kind="function" class="blk"><title>split — function, 24 lines</title></rect>
-<rect x="692.0" y="2117.0" width="74.0" height="51.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.classify" data-kind="function" class="blk"><title>classify — function, 102 lines</title></rect>
+<rect x="28.0" y="1471.5" width="74.0" height="14.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.ir — 7 lines</title></rect>
+<rect x="110.0" y="1471.5" width="74.0" height="14.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors — 2 lines</title></rect>
+<rect x="210.0" y="1471.5" width="74.0" height="269.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.site — 539 lines</title></rect>
+<rect x="210.0" y="1629.0" width="74.0" height="27.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site._ledger" data-kind="function" class="blk"><title>_ledger — function, 54 lines</title></rect>
+<rect x="210.0" y="1657.0" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site._slots" data-kind="function" class="blk"><title>_slots — function, 15 lines</title></rect>
+<rect x="210.0" y="1665.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site._fill" data-kind="function" class="blk"><title>_fill — function, 4 lines</title></rect>
+<rect x="210.0" y="1668.5" width="74.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site._sidebar" data-kind="function" class="blk"><title>_sidebar — function, 17 lines</title></rect>
+<rect x="210.0" y="1678.0" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site._sections" data-kind="function" class="blk"><title>_sections — function, 15 lines</title></rect>
+<rect x="210.0" y="1686.5" width="74.0" height="48.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site.emit" data-kind="function" class="blk"><title>emit — function, 96 lines</title></rect>
+<rect x="210.0" y="1735.5" width="74.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.site.write" data-kind="function" class="blk"><title>write — function, 10 lines</title></rect>
+<rect x="292.0" y="1471.5" width="74.0" height="160.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.notebook — 320 lines</title></rect>
+<rect x="292.0" y="1492.5" width="74.0" height="9.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._cell" data-kind="function" class="blk"><title>_cell — function, 19 lines</title></rect>
+<rect x="292.0" y="1503.0" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._example" data-kind="function" class="blk"><title>_example — function, 26 lines</title></rect>
+<rect x="292.0" y="1536.5" width="74.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._params_cell" data-kind="function" class="blk"><title>_params_cell — function, 18 lines</title></rect>
+<rect x="292.0" y="1546.5" width="74.0" height="20.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._call_cell" data-kind="function" class="blk"><title>_call_cell — function, 40 lines</title></rect>
+<rect x="292.0" y="1567.5" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._call_md" data-kind="function" class="blk"><title>_call_md — function, 26 lines</title></rect>
+<rect x="292.0" y="1581.5" width="74.0" height="10.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._figure_md" data-kind="function" class="blk"><title>_figure_md — function, 21 lines</title></rect>
+<rect x="292.0" y="1593.0" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook._figure_attachments" data-kind="function" class="blk"><title>_figure_attachments — function, 7 lines</title></rect>
+<rect x="292.0" y="1597.5" width="74.0" height="27.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook.build" data-kind="function" class="blk"><title>build — function, 55 lines</title></rect>
+<rect x="292.0" y="1626.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook.emit" data-kind="function" class="blk"><title>emit — function, 3 lines</title></rect>
+<rect x="292.0" y="1628.5" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.notebook.write" data-kind="function" class="blk"><title>write — function, 5 lines</title></rect>
+<rect x="374.0" y="1471.5" width="74.0" height="158.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.explore — 316 lines</title></rect>
+<rect x="374.0" y="1491.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.explore._is_schema" data-kind="function" class="blk"><title>_is_schema — function, 4 lines</title></rect>
+<rect x="374.0" y="1494.0" width="74.0" height="24.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.explore._neighbourhood_svgs" data-kind="function" class="blk"><title>_neighbourhood_svgs — function, 48 lines</title></rect>
+<rect x="381.0" y="1500.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.explore._neighbourhood_svgs.render_one" data-kind="function" class="blk"><title>render_one — function, 2 lines</title></rect>
+<rect x="381.0" y="1504.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.explore._neighbourhood_svgs.render_one#L66" data-kind="function" class="blk"><title>render_one — function, 2 lines</title></rect>
+<rect x="374.0" y="1519.0" width="74.0" height="13.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.explore._facts" data-kind="function" class="blk"><title>_facts — function, 27 lines</title></rect>
+<rect x="374.0" y="1533.5" width="74.0" height="86.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.explore.emit" data-kind="function" class="blk"><title>emit — function, 172 lines</title></rect>
+<rect x="374.0" y="1620.5" width="74.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.explore.write" data-kind="function" class="blk"><title>write — function, 17 lines</title></rect>
+<rect x="456.0" y="1471.5" width="74.0" height="154.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.dot — 309 lines</title></rect>
+<rect x="456.0" y="1490.0" width="74.0" height="2.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.emitters.dot.RenderError" data-kind="class" class="blk"><title>RenderError — class, 2 lines</title></rect>
+<rect x="456.0" y="1492.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._esc" data-kind="function" class="blk"><title>_esc — function, 2 lines</title></rect>
+<rect x="456.0" y="1494.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._attrs" data-kind="function" class="blk"><title>_attrs — function, 3 lines</title></rect>
+<rect x="456.0" y="1496.5" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._style_words" data-kind="function" class="blk"><title>_style_words — function, 9 lines</title></rect>
+<rect x="456.0" y="1502.0" width="74.0" height="16.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._node_attrs" data-kind="function" class="blk"><title>_node_attrs — function, 33 lines</title></rect>
+<rect x="456.0" y="1519.5" width="74.0" height="56.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot.emit" data-kind="function" class="blk"><title>emit — function, 113 lines</title></rect>
+<rect x="463.0" y="1536.0" width="60.0" height="15.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.dot.emit.write" data-kind="function" class="blk"><title>write — function, 31 lines</title></rect>
+<rect x="456.0" y="1577.0" width="74.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._within" data-kind="function" class="blk"><title>_within — function, 8 lines</title></rect>
+<rect x="456.0" y="1582.0" width="74.0" height="20.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._endpoints" data-kind="function" class="blk"><title>_endpoints — function, 41 lines</title></rect>
+<rect x="463.0" y="1587.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.dot._endpoints.walk" data-kind="function" class="blk"><title>walk — function, 4 lines</title></rect>
+<rect x="463.0" y="1591.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.dot._endpoints.collapsed" data-kind="function" class="blk"><title>collapsed — function, 2 lines</title></rect>
+<rect x="463.0" y="1592.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.dot._endpoints.first_leaf" data-kind="function" class="blk"><title>first_leaf — function, 4 lines</title></rect>
+<rect x="456.0" y="1603.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._safe" data-kind="function" class="blk"><title>_safe — function, 2 lines</title></rect>
+<rect x="456.0" y="1605.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot._q" data-kind="function" class="blk"><title>_q — function, 2 lines</title></rect>
+<rect x="456.0" y="1609.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot.have_graphviz" data-kind="function" class="blk"><title>have_graphviz — function, 2 lines</title></rect>
+<rect x="456.0" y="1611.0" width="74.0" height="14.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.dot.render" data-kind="function" class="blk"><title>render — function, 29 lines</title></rect>
+<rect x="538.0" y="1471.5" width="74.0" height="139.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.minimap — 278 lines</title></rect>
+<rect x="538.0" y="1503.0" width="74.0" height="28.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.minimap._files" data-kind="function" class="blk"><title>_files — function, 57 lines</title></rect>
+<rect x="545.0" y="1507.0" width="60.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.minimap._files.declared" data-kind="function" class="blk"><title>declared — function, 18 lines</title></rect>
+<rect x="545.0" y="1516.5" width="60.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.minimap._files.build" data-kind="function" class="blk"><title>build — function, 11 lines</title></rect>
+<rect x="538.0" y="1532.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.minimap._bands" data-kind="function" class="blk"><title>_bands — function, 7 lines</title></rect>
+<rect x="538.0" y="1537.0" width="74.0" height="9.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.minimap._blocks" data-kind="function" class="blk"><title>_blocks — function, 19 lines</title></rect>
+<rect x="538.0" y="1547.5" width="74.0" height="60.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.minimap.emit" data-kind="function" class="blk"><title>emit — function, 120 lines</title></rect>
+<rect x="538.0" y="1608.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.minimap.marks_to_labels" data-kind="function" class="blk"><title>marks_to_labels — function, 3 lines</title></rect>
+<rect x="620.0" y="1471.5" width="74.0" height="138.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.erd — 276 lines</title></rect>
+<rect x="620.0" y="1498.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd._truncate" data-kind="function" class="blk"><title>_truncate — function, 3 lines</title></rect>
+<rect x="620.0" y="1501.0" width="74.0" height="10.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd._tables" data-kind="function" class="blk"><title>_tables — function, 20 lines</title></rect>
+<rect x="620.0" y="1512.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd._card_height" data-kind="function" class="blk"><title>_card_height — function, 3 lines</title></rect>
+<rect x="620.0" y="1514.5" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd.max_columns" data-kind="function" class="blk"><title>max_columns — function, 9 lines</title></rect>
+<rect x="620.0" y="1520.0" width="74.0" height="12.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd.layout" data-kind="function" class="blk"><title>layout — function, 25 lines</title></rect>
+<rect x="620.0" y="1533.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd._field_y" data-kind="function" class="blk"><title>_field_y — function, 3 lines</title></rect>
+<rect x="620.0" y="1536.0" width="74.0" height="73.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.erd.emit" data-kind="function" class="blk"><title>emit — function, 146 lines</title></rect>
+<rect x="702.0" y="1471.5" width="74.0" height="135.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.docsite — 270 lines</title></rect>
+<rect x="702.0" y="1504.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.docsite._note" data-kind="function" class="blk"><title>_note — function, 7 lines</title></rect>
+<rect x="702.0" y="1509.0" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.docsite._missing" data-kind="function" class="blk"><title>_missing — function, 9 lines</title></rect>
+<rect x="702.0" y="1514.5" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.docsite._tree" data-kind="function" class="blk"><title>_tree — function, 15 lines</title></rect>
+<rect x="709.0" y="1517.5" width="60.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.docsite._tree.walk" data-kind="function" class="blk"><title>walk — function, 7 lines</title></rect>
+<rect x="702.0" y="1523.0" width="74.0" height="34.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.docsite._page" data-kind="function" class="blk"><title>_page — function, 69 lines</title></rect>
+<rect x="702.0" y="1558.5" width="74.0" height="47.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.docsite.write" data-kind="function" class="blk"><title>write — function, 95 lines</title></rect>
+<rect x="709.0" y="1566.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.docsite.write.put" data-kind="function" class="blk"><title>put — function, 4 lines</title></rect>
+<rect x="784.0" y="1471.5" width="74.0" height="82.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.index — 164 lines</title></rect>
+<rect x="784.0" y="1488.5" width="74.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.index._tree" data-kind="function" class="blk"><title>_tree — function, 8 lines</title></rect>
+<rect x="784.0" y="1493.5" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.index._anchor" data-kind="function" class="blk"><title>_anchor — function, 5 lines</title></rect>
+<rect x="784.0" y="1497.0" width="74.0" height="42.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.index.to_markdown" data-kind="function" class="blk"><title>to_markdown — function, 84 lines</title></rect>
+<rect x="791.0" y="1508.5" width="60.0" height="13.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.index.to_markdown.walk" data-kind="function" class="blk"><title>walk — function, 27 lines</title></rect>
+<rect x="784.0" y="1540.0" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.index.to_sidebar" data-kind="function" class="blk"><title>to_sidebar — function, 26 lines</title></rect>
+<rect x="791.0" y="1543.5" width="60.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.index.to_sidebar.build" data-kind="function" class="blk"><title>build — function, 13 lines</title></rect>
+<rect x="28.0" y="1779.0" width="74.0" height="73.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.markdown — 146 lines</title></rect>
+<rect x="28.0" y="1789.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.markdown._url" data-kind="function" class="blk"><title>_url — function, 7 lines</title></rect>
+<rect x="28.0" y="1798.5" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.markdown._inline" data-kind="function" class="blk"><title>_inline — function, 13 lines</title></rect>
+<rect x="35.0" y="1800.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.markdown._inline.keep" data-kind="function" class="blk"><title>keep — function, 3 lines</title></rect>
+<rect x="28.0" y="1806.0" width="74.0" height="45.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.markdown.to_html" data-kind="function" class="blk"><title>to_html — function, 91 lines</title></rect>
+<rect x="35.0" y="1809.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.markdown.to_html.para" data-kind="function" class="blk"><title>para — function, 3 lines</title></rect>
+<rect x="35.0" y="1841.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.markdown.to_html.cells" data-kind="function" class="blk"><title>cells — function, 2 lines</title></rect>
+<rect x="110.0" y="1779.0" width="74.0" height="59.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.paged — 119 lines</title></rect>
+<rect x="110.0" y="1795.0" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.paged.svg_width_px" data-kind="function" class="blk"><title>svg_width_px — function, 6 lines</title></rect>
+<rect x="110.0" y="1799.0" width="74.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.paged._estimate_px" data-kind="function" class="blk"><title>_estimate_px — function, 10 lines</title></rect>
+<rect x="110.0" y="1805.0" width="74.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.paged.fits_for" data-kind="function" class="blk"><title>fits_for — function, 17 lines</title></rect>
+<rect x="117.0" y="1809.5" width="60.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.emitters.paged.fits_for.fits" data-kind="function" class="blk"><title>fits — function, 6 lines</title></rect>
+<rect x="110.0" y="1814.5" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.paged.links_for" data-kind="function" class="blk"><title>links_for — function, 15 lines</title></rect>
+<rect x="110.0" y="1823.0" width="74.0" height="9.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.paged.render" data-kind="function" class="blk"><title>render — function, 19 lines</title></rect>
+<rect x="110.0" y="1833.5" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.paged.inline" data-kind="function" class="blk"><title>inline — function, 9 lines</title></rect>
+<rect x="192.0" y="1779.0" width="74.0" height="32.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.emitters.auto — 64 lines</title></rect>
+<rect x="192.0" y="1792.5" width="74.0" height="18.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.emitters.auto.draw" data-kind="function" class="blk"><title>draw — function, 36 lines</title></rect>
+<rect x="292.0" y="1779.0" width="74.0" height="126.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.emit — 253 lines</title></rect>
+<rect x="292.0" y="1791.0" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit._parser" data-kind="function" class="blk"><title>_parser — function, 7 lines</title></rect>
+<rect x="292.0" y="1795.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit._size" data-kind="function" class="blk"><title>_size — function, 3 lines</title></rect>
+<rect x="292.0" y="1798.0" width="74.0" height="8.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.auto" data-kind="function" class="blk"><title>auto — function, 16 lines</title></rect>
+<rect x="292.0" y="1807.0" width="74.0" height="19.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.dot" data-kind="function" class="blk"><title>dot — function, 38 lines</title></rect>
+<rect x="292.0" y="1827.0" width="74.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.erd" data-kind="function" class="blk"><title>erd — function, 11 lines</title></rect>
+<rect x="292.0" y="1833.5" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.index" data-kind="function" class="blk"><title>index — function, 14 lines</title></rect>
+<rect x="292.0" y="1841.5" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.minimap" data-kind="function" class="blk"><title>minimap — function, 14 lines</title></rect>
+<rect x="292.0" y="1849.5" width="74.0" height="20.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.notebook" data-kind="function" class="blk"><title>notebook — function, 41 lines</title></rect>
+<rect x="292.0" y="1871.0" width="74.0" height="15.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.site" data-kind="function" class="blk"><title>site — function, 31 lines</title></rect>
+<rect x="292.0" y="1887.5" width="74.0" height="11.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.explore" data-kind="function" class="blk"><title>explore — function, 22 lines</title></rect>
+<rect x="292.0" y="1901.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.emit.main" data-kind="function" class="blk"><title>main — function, 7 lines</title></rect>
+<rect x="374.0" y="1779.0" width="74.0" height="59.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.extract — 119 lines</title></rect>
+<rect x="374.0" y="1788.5" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract._parser" data-kind="function" class="blk"><title>_parser — function, 5 lines</title></rect>
+<rect x="374.0" y="1792.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract._counts" data-kind="function" class="blk"><title>_counts — function, 3 lines</title></rect>
+<rect x="374.0" y="1794.5" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.python" data-kind="function" class="blk"><title>python — function, 15 lines</title></rect>
+<rect x="374.0" y="1803.0" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.code" data-kind="function" class="blk"><title>code — function, 14 lines</title></rect>
+<rect x="374.0" y="1811.0" width="74.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.db" data-kind="function" class="blk"><title>db — function, 11 lines</title></rect>
+<rect x="374.0" y="1817.5" width="74.0" height="6.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.openapi" data-kind="function" class="blk"><title>openapi — function, 12 lines</title></rect>
+<rect x="374.0" y="1824.5" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.usage" data-kind="function" class="blk"><title>usage — function, 15 lines</title></rect>
+<rect x="374.0" y="1834.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.extract.main" data-kind="function" class="blk"><title>main — function, 7 lines</title></rect>
+<rect x="456.0" y="1779.0" width="74.0" height="49.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.run — 99 lines</title></rect>
+<rect x="456.0" y="1789.0" width="74.0" height="39.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.run.main" data-kind="function" class="blk"><title>main — function, 78 lines</title></rect>
+<rect x="538.0" y="1779.0" width="74.0" height="45.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.view — 90 lines</title></rect>
+<rect x="538.0" y="1786.0" width="74.0" height="37.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.view.main" data-kind="function" class="blk"><title>main — function, 75 lines</title></rect>
+<rect x="620.0" y="1779.0" width="74.0" height="44.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.scaffold — 88 lines</title></rect>
+<rect x="620.0" y="1789.5" width="74.0" height="33.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.scaffold.main" data-kind="function" class="blk"><title>main — function, 66 lines</title></rect>
+<rect x="702.0" y="1779.0" width="74.0" height="40.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.common — 80 lines</title></rect>
+<rect x="702.0" y="1789.0" width="74.0" height="2.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.cli.common.Abort" data-kind="class" class="blk"><title>Abort — class, 2 lines</title></rect>
+<rect x="702.0" y="1791.0" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.read_json" data-kind="function" class="blk"><title>read_json — function, 5 lines</title></rect>
+<rect x="702.0" y="1794.5" width="74.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.read_ir" data-kind="function" class="blk"><title>read_ir — function, 11 lines</title></rect>
+<rect x="702.0" y="1801.0" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.load_style" data-kind="function" class="blk"><title>load_style — function, 7 lines</title></rect>
+<rect x="702.0" y="1805.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.style_args" data-kind="function" class="blk"><title>style_args — function, 3 lines</title></rect>
+<rect x="702.0" y="1808.0" width="74.0" height="8.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.emit" data-kind="function" class="blk"><title>emit — function, 16 lines</title></rect>
+<rect x="702.0" y="1817.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.common.dump_ir" data-kind="function" class="blk"><title>dump_ir — function, 3 lines</title></rect>
+<rect x="784.0" y="1779.0" width="74.0" height="38.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.book — 77 lines</title></rect>
+<rect x="784.0" y="1789.5" width="74.0" height="27.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.book.main" data-kind="function" class="blk"><title>main — function, 55 lines</title></rect>
+<rect x="28.0" y="1943.5" width="74.0" height="29.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.check — 58 lines</title></rect>
+<rect x="28.0" y="1953.5" width="74.0" height="18.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.check.main" data-kind="function" class="blk"><title>main — function, 37 lines</title></rect>
+<rect x="110.0" y="1943.5" width="74.0" height="17.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.contract — 34 lines</title></rect>
+<rect x="110.0" y="1956.0" width="74.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.contract.main" data-kind="function" class="blk"><title>main — function, 8 lines</title></rect>
+<rect x="192.0" y="1943.5" width="74.0" height="16.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.cli.validate — 33 lines</title></rect>
+<rect x="192.0" y="1950.5" width="74.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.cli.validate.main" data-kind="function" class="blk"><title>main — function, 18 lines</title></rect>
+<rect x="292.0" y="1943.5" width="74.0" height="308.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.book.config — 616 lines</title></rect>
+<rect x="292.0" y="1984.0" width="74.0" height="3.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.config.ConfigError" data-kind="class" class="blk"><title>ConfigError — class, 6 lines</title></rect>
+<rect x="299.0" y="1985.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.config.ConfigError.__init__" data-kind="function" class="blk"><title>__init__ — function, 3 lines</title></rect>
+<rect x="292.0" y="1988.5" width="74.0" height="7.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.config.Entry" data-kind="class" class="blk"><title>Entry — class, 15 lines</title></rect>
+<rect x="299.0" y="1995.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.config.Entry.line" data-kind="function" class="blk"><title>line — function, 2 lines</title></rect>
+<rect x="292.0" y="1997.5" width="74.0" height="8.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.config.RunFile" data-kind="class" class="blk"><title>RunFile — class, 17 lines</title></rect>
+<rect x="299.0" y="2000.0" width="60.0" height="6.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.config.RunFile.select" data-kind="function" class="blk"><title>select — function, 12 lines</title></rect>
+<rect x="292.0" y="2007.0" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config._path" data-kind="function" class="blk"><title>_path — function, 6 lines</title></rect>
+<rect x="292.0" y="2011.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config._within" data-kind="function" class="blk"><title>_within — function, 3 lines</title></rect>
+<rect x="292.0" y="2013.5" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config._read" data-kind="function" class="blk"><title>_read — function, 9 lines</title></rect>
+<rect x="292.0" y="2019.0" width="74.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config.load" data-kind="function" class="blk"><title>load — function, 18 lines</title></rect>
+<rect x="292.0" y="2029.0" width="74.0" height="60.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config._load_books" data-kind="function" class="blk"><title>_load_books — function, 121 lines</title></rect>
+<rect x="299.0" y="2055.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.config._load_books.pick" data-kind="function" class="blk"><title>pick — function, 3 lines</title></rect>
+<rect x="292.0" y="2090.5" width="74.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config.apply_reference" data-kind="function" class="blk"><title>apply_reference — function, 11 lines</title></rect>
+<rect x="292.0" y="2097.0" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config._checks" data-kind="function" class="blk"><title>_checks — function, 13 lines</title></rect>
+<rect x="292.0" y="2104.5" width="74.0" height="18.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config.run" data-kind="function" class="blk"><title>run — function, 36 lines</title></rect>
+<rect x="292.0" y="2143.5" width="74.0" height="4.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.config.ProjectFile" data-kind="class" class="blk"><title>ProjectFile — class, 8 lines</title></rect>
+<rect x="299.0" y="2146.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.config.ProjectFile.books" data-kind="function" class="blk"><title>books — function, 2 lines</title></rect>
+<rect x="292.0" y="2148.5" width="74.0" height="75.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config.load_project" data-kind="function" class="blk"><title>load_project — function, 151 lines</title></rect>
+<rect x="292.0" y="2225.0" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config.select_parts" data-kind="function" class="blk"><title>select_parts — function, 9 lines</title></rect>
+<rect x="292.0" y="2230.5" width="74.0" height="20.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.config.run_project" data-kind="function" class="blk"><title>run_project — function, 41 lines</title></rect>
+<rect x="374.0" y="1943.5" width="74.0" height="224.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.book.document — 449 lines</title></rect>
+<rect x="374.0" y="1964.5" width="74.0" height="3.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.document.Output" data-kind="class" class="blk"><title>Output — class, 6 lines</title></rect>
+<rect x="374.0" y="1969.0" width="74.0" height="5.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.document.Part" data-kind="class" class="blk"><title>Part — class, 11 lines</title></rect>
+<rect x="374.0" y="1976.0" width="74.0" height="5.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.document.Document" data-kind="class" class="blk"><title>Document — class, 11 lines</title></rect>
+<rect x="374.0" y="1985.0" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document.apply_ops" data-kind="function" class="blk"><title>apply_ops — function, 15 lines</title></rect>
+<rect x="374.0" y="1994.5" width="74.0" height="13.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document.clear_output" data-kind="function" class="blk"><title>clear_output — function, 27 lines</title></rect>
+<rect x="374.0" y="2009.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document.write_manifest" data-kind="function" class="blk"><title>write_manifest — function, 3 lines</title></rect>
+<rect x="374.0" y="2012.5" width="74.0" height="11.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document.rendered_pages" data-kind="function" class="blk"><title>rendered_pages — function, 22 lines</title></rect>
+<rect x="374.0" y="2024.5" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document.caption" data-kind="function" class="blk"><title>caption — function, 14 lines</title></rect>
+<rect x="374.0" y="2033.5" width="74.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document._note_step" data-kind="function" class="blk"><title>_note_step — function, 8 lines</title></rect>
+<rect x="374.0" y="2038.5" width="74.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document._with_note" data-kind="function" class="blk"><title>_with_note — function, 11 lines</title></rect>
+<rect x="374.0" y="2045.0" width="74.0" height="45.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document.notebook_spec" data-kind="function" class="blk"><title>notebook_spec — function, 91 lines</title></rect>
+<rect x="374.0" y="2092.5" width="74.0" height="58.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document.build" data-kind="function" class="blk"><title>build — function, 116 lines</title></rect>
+<rect x="381.0" y="2096.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.document.build.say" data-kind="function" class="blk"><title>say — function, 3 lines</title></rect>
+<rect x="374.0" y="2151.5" width="74.0" height="8.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document._spots" data-kind="function" class="blk"><title>_spots — function, 16 lines</title></rect>
+<rect x="374.0" y="2160.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document.known_spots" data-kind="function" class="blk"><title>known_spots — function, 3 lines</title></rect>
+<rect x="374.0" y="2163.0" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.document.plan_spots" data-kind="function" class="blk"><title>plan_spots — function, 9 lines</title></rect>
+<rect x="456.0" y="1943.5" width="74.0" height="209.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.book.build — 418 lines</title></rect>
+<rect x="456.0" y="1981.0" width="74.0" height="14.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.build.extract" data-kind="function" class="blk"><title>extract — function, 29 lines</title></rect>
+<rect x="456.0" y="1996.5" width="74.0" height="35.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.build.spec_from" data-kind="function" class="blk"><title>spec_from — function, 71 lines</title></rect>
+<rect x="456.0" y="2033.0" width="74.0" height="23.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.build._load_cell" data-kind="function" class="blk"><title>_load_cell — function, 46 lines</title></rect>
+<rect x="456.0" y="2067.0" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.build.clear" data-kind="function" class="blk"><title>clear — function, 26 lines</title></rect>
+<rect x="456.0" y="2081.0" width="74.0" height="52.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.build.build_book" data-kind="function" class="blk"><title>build_book — function, 105 lines</title></rect>
+<rect x="463.0" y="2091.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.build.build_book.say" data-kind="function" class="blk"><title>say — function, 3 lines</title></rect>
+<rect x="456.0" y="2134.5" width="74.0" height="17.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.build.run" data-kind="function" class="blk"><title>run — function, 35 lines</title></rect>
+<rect x="538.0" y="1943.5" width="74.0" height="189.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.book.checks — 378 lines</title></rect>
+<rect x="538.0" y="1974.0" width="74.0" height="13.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.checks.Loaded" data-kind="class" class="blk"><title>Loaded — class, 26 lines</title></rect>
+<rect x="545.0" y="1975.5" width="60.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Loaded.__init__" data-kind="function" class="blk"><title>__init__ — function, 15 lines</title></rect>
+<rect x="545.0" y="1984.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Loaded.larder" data-kind="function" class="blk"><title>larder — function, 2 lines</title></rect>
+<rect x="545.0" y="1986.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Loaded.measure" data-kind="function" class="blk"><title>measure — function, 2 lines</title></rect>
+<rect x="538.0" y="1988.0" width="74.0" height="19.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.checks.Report" data-kind="class" class="blk"><title>Report — class, 38 lines</title></rect>
+<rect x="545.0" y="1989.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Report.__init__" data-kind="function" class="blk"><title>__init__ — function, 3 lines</title></rect>
+<rect x="545.0" y="1991.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Report.note" data-kind="function" class="blk"><title>note — function, 2 lines</title></rect>
+<rect x="545.0" y="1993.0" width="60.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Report.check" data-kind="function" class="blk"><title>check — function, 8 lines</title></rect>
+<rect x="545.0" y="1997.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Report.skip" data-kind="function" class="blk"><title>skip — function, 3 lines</title></rect>
+<rect x="545.0" y="1999.5" width="60.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.Report.total" data-kind="function" class="blk"><title>total — function, 15 lines</title></rect>
+<rect x="538.0" y="2008.0" width="74.0" height="44.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.checks.generated" data-kind="function" class="blk"><title>generated — function, 89 lines</title></rect>
+<rect x="538.0" y="2053.5" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.checks.custom" data-kind="function" class="blk"><title>custom — function, 26 lines</title></rect>
+<rect x="538.0" y="2067.5" width="74.0" height="16.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.checks._run_cells" data-kind="function" class="blk"><title>_run_cells — function, 33 lines</title></rect>
+<rect x="538.0" y="2086.0" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.checks._notes_drift" data-kind="function" class="blk"><title>_notes_drift — function, 7 lines</title></rect>
+<rect x="538.0" y="2090.5" width="74.0" height="36.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.checks.document" data-kind="function" class="blk"><title>document — function, 72 lines</title></rect>
+<rect x="545.0" y="2104.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.checks.document.heading" data-kind="function" class="blk"><title>heading — function, 2 lines</title></rect>
+<rect x="538.0" y="2127.5" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.checks.document_failures" data-kind="function" class="blk"><title>document_failures — function, 9 lines</title></rect>
+<rect x="620.0" y="1943.5" width="74.0" height="98.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.book.larder — 196 lines</title></rect>
+<rect x="620.0" y="1975.0" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.larder._count" data-kind="function" class="blk"><title>_count — function, 13 lines</title></rect>
+<rect x="620.0" y="1982.5" width="74.0" height="16.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.larder.redact" data-kind="function" class="blk"><title>redact — function, 32 lines</title></rect>
+<rect x="620.0" y="2000.0" width="74.0" height="38.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.larder.Larder" data-kind="class" class="blk"><title>Larder — class, 77 lines</title></rect>
+<rect x="627.0" y="2007.0" width="60.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.__post_init__" data-kind="function" class="blk"><title>__post_init__ — function, 7 lines</title></rect>
+<rect x="627.0" y="2011.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.read" data-kind="function" class="blk"><title>read — function, 3 lines</title></rect>
+<rect x="627.0" y="2013.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.fail" data-kind="function" class="blk"><title>fail — function, 3 lines</title></rect>
+<rect x="627.0" y="2015.5" width="60.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.to_dict" data-kind="function" class="blk"><title>to_dict — function, 13 lines</title></rect>
+<rect x="627.0" y="2023.0" width="60.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.from_dict" data-kind="function" class="blk"><title>from_dict — function, 10 lines</title></rect>
+<rect x="627.0" y="2028.5" width="60.0" height="10.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.larder.Larder.line" data-kind="function" class="blk"><title>line — function, 20 lines</title></rect>
+<rect x="620.0" y="2039.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.larder.of" data-kind="function" class="blk"><title>of — function, 3 lines</title></rect>
+<rect x="702.0" y="1943.5" width="74.0" height="81.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.book.notes — 162 lines</title></rect>
+<rect x="702.0" y="1966.5" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.notes.body" data-kind="function" class="blk"><title>body — function, 6 lines</title></rect>
+<rect x="702.0" y="1970.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.notes.stub" data-kind="function" class="blk"><title>stub — function, 3 lines</title></rect>
+<rect x="702.0" y="1973.0" width="74.0" height="39.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.book.notes.Notes" data-kind="class" class="blk"><title>Notes — class, 78 lines</title></rect>
+<rect x="709.0" y="1974.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.notes.Notes.__init__" data-kind="function" class="blk"><title>__init__ — function, 3 lines</title></rect>
+<rect x="709.0" y="1976.5" width="60.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.notes.Notes._read" data-kind="function" class="blk"><title>_read — function, 7 lines</title></rect>
+<rect x="709.0" y="1980.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.notes.Notes.document" data-kind="function" class="blk"><title>document — function, 2 lines</title></rect>
+<rect x="709.0" y="1982.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.notes.Notes.book" data-kind="function" class="blk"><title>book — function, 2 lines</title></rect>
+<rect x="709.0" y="1983.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.notes.Notes.path" data-kind="function" class="blk"><title>path — function, 4 lines</title></rect>
+<rect x="709.0" y="1986.0" width="60.0" height="13.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.notes.Notes.drift" data-kind="function" class="blk"><title>drift — function, 27 lines</title></rect>
+<rect x="709.0" y="2000.0" width="60.0" height="12.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.book.notes.Notes.scaffold" data-kind="function" class="blk"><title>scaffold — function, 24 lines</title></rect>
+<rect x="702.0" y="2013.0" width="74.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.notes.images" data-kind="function" class="blk"><title>images — function, 18 lines</title></rect>
+<rect x="702.0" y="2023.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.book.notes.data_uri" data-kind="function" class="blk"><title>data_uri — function, 2 lines</title></rect>
+<rect x="28.0" y="2289.5" width="74.0" height="141.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.code — 282 lines</title></rect>
+<rect x="28.0" y="2337.0" width="74.0" height="2.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.extractors.code.MissingParser" data-kind="class" class="blk"><title>MissingParser — class, 2 lines</title></rect>
+<rect x="28.0" y="2339.0" width="74.0" height="10.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code._parser" data-kind="function" class="blk"><title>_parser — function, 21 lines</title></rect>
+<rect x="28.0" y="2350.5" width="74.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code._name" data-kind="function" class="blk"><title>_name — function, 10 lines</title></rect>
+<rect x="28.0" y="2356.5" width="74.0" height="17.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code._walk" data-kind="function" class="blk"><title>_walk — function, 34 lines</title></rect>
+<rect x="28.0" y="2374.5" width="74.0" height="13.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code.extract_file" data-kind="function" class="blk"><title>extract_file — function, 27 lines</title></rect>
+<rect x="28.0" y="2389.0" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code._count_errors" data-kind="function" class="blk"><title>_count_errors — function, 5 lines</title></rect>
+<rect x="28.0" y="2392.5" width="74.0" height="37.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.code.extract" data-kind="function" class="blk"><title>extract — function, 75 lines</title></rect>
+<rect x="110.0" y="2289.5" width="74.0" height="134.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.usage — 269 lines</title></rect>
+<rect x="110.0" y="2321.5" width="74.0" height="13.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.usage._template" data-kind="function" class="blk"><title>_template — function, 27 lines</title></rect>
+<rect x="110.0" y="2336.0" width="74.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.usage._body" data-kind="function" class="blk"><title>_body — function, 10 lines</title></rect>
+<rect x="110.0" y="2342.0" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.usage._shape" data-kind="function" class="blk"><title>_shape — function, 15 lines</title></rect>
+<rect x="110.0" y="2350.5" width="74.0" height="5.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.usage._graphql" data-kind="function" class="blk"><title>_graphql — function, 11 lines</title></rect>
+<rect x="110.0" y="2357.0" width="74.0" height="66.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.usage.extract" data-kind="function" class="blk"><title>extract — function, 133 lines</title></rect>
+<rect x="192.0" y="2289.5" width="74.0" height="95.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.openapi — 191 lines</title></rect>
+<rect x="192.0" y="2305.0" width="74.0" height="14.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.openapi._modelgen" data-kind="function" class="blk"><title>_modelgen — function, 28 lines</title></rect>
+<rect x="192.0" y="2320.0" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.openapi._type_name" data-kind="function" class="blk"><title>_type_name — function, 6 lines</title></rect>
+<rect x="192.0" y="2324.0" width="74.0" height="21.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.openapi._refs" data-kind="function" class="blk"><title>_refs — function, 43 lines</title></rect>
+<rect x="192.0" y="2346.5" width="74.0" height="38.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.openapi.extract" data-kind="function" class="blk"><title>extract — function, 76 lines</title></rect>
+<rect x="274.0" y="2289.5" width="74.0" height="80.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.db — 161 lines</title></rect>
+<rect x="274.0" y="2309.0" width="74.0" height="41.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.db.from_schema_dict" data-kind="function" class="blk"><title>from_schema_dict — function, 82 lines</title></rect>
+<rect x="274.0" y="2351.0" width="74.0" height="5.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.db._relation" data-kind="function" class="blk"><title>_relation — function, 10 lines</title></rect>
+<rect x="274.0" y="2357.0" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.db._plain_type" data-kind="function" class="blk"><title>_plain_type — function, 6 lines</title></rect>
+<rect x="274.0" y="2361.0" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.db._dedupe" data-kind="function" class="blk"><title>_dedupe — function, 9 lines</title></rect>
+<rect x="274.0" y="2366.5" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.db.extract" data-kind="function" class="blk"><title>extract — function, 6 lines</title></rect>
+<rect x="356.0" y="2289.5" width="74.0" height="18.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.python — 37 lines</title></rect>
+<rect x="356.0" y="2299.0" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.extract" data-kind="function" class="blk"><title>extract — function, 14 lines</title></rect>
+<rect x="456.0" y="2289.5" width="74.0" height="118.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.python.collect — 236 lines</title></rect>
+<rect x="456.0" y="2306.0" width="74.0" height="5.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect.Definition" data-kind="class" class="blk"><title>Definition — class, 10 lines</title></rect>
+<rect x="456.0" y="2312.5" width="74.0" height="6.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect.Module" data-kind="class" class="blk"><title>Module — class, 12 lines</title></rect>
+<rect x="456.0" y="2319.5" width="74.0" height="33.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect._Collector" data-kind="class" class="blk"><title>_Collector — class, 67 lines</title></rect>
+<rect x="463.0" y="2321.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector.__init__" data-kind="function" class="blk"><title>__init__ — function, 3 lines</title></rect>
+<rect x="463.0" y="2324.0" width="60.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector._define" data-kind="function" class="blk"><title>_define — function, 17 lines</title></rect>
+<rect x="463.0" y="2333.0" width="60.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector.visit_ClassDef" data-kind="function" class="blk"><title>visit_ClassDef — function, 5 lines</title></rect>
+<rect x="463.0" y="2336.0" width="60.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector.visit_FunctionDef" data-kind="function" class="blk"><title>visit_FunctionDef — function, 5 lines</title></rect>
+<rect x="463.0" y="2341.5" width="60.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector.visit_Import" data-kind="function" class="blk"><title>visit_Import — function, 8 lines</title></rect>
+<rect x="463.0" y="2346.0" width="60.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.collect._Collector.visit_ImportFrom" data-kind="function" class="blk"><title>visit_ImportFrom — function, 14 lines</title></rect>
+<rect x="456.0" y="2354.0" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect._first_line" data-kind="function" class="blk"><title>_first_line — function, 5 lines</title></rect>
+<rect x="456.0" y="2357.5" width="74.0" height="7.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect._name_of" data-kind="function" class="blk"><title>_name_of — function, 15 lines</title></rect>
+<rect x="456.0" y="2366.0" width="74.0" height="8.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect._resolve_relative" data-kind="function" class="blk"><title>_resolve_relative — function, 16 lines</title></rect>
+<rect x="456.0" y="2375.0" width="74.0" height="13.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect.module_name" data-kind="function" class="blk"><title>module_name — function, 26 lines</title></rect>
+<rect x="456.0" y="2389.0" width="74.0" height="10.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect.collect_file" data-kind="function" class="blk"><title>collect_file — function, 21 lines</title></rect>
+<rect x="456.0" y="2400.5" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.collect.collect" data-kind="function" class="blk"><title>collect — function, 13 lines</title></rect>
+<rect x="538.0" y="2289.5" width="74.0" height="92.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.extractors.python.resolve — 184 lines</title></rect>
+<rect x="538.0" y="2303.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.resolve._id_for" data-kind="function" class="blk"><title>_id_for — function, 2 lines</title></rect>
+<rect x="538.0" y="2305.5" width="74.0" height="16.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.resolve._resolve" data-kind="function" class="blk"><title>_resolve — function, 32 lines</title></rect>
+<rect x="538.0" y="2322.5" width="74.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.resolve.larder_of" data-kind="function" class="blk"><title>larder_of — function, 17 lines</title></rect>
+<rect x="538.0" y="2332.0" width="74.0" height="49.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.extractors.python.resolve.to_ir" data-kind="function" class="blk"><title>to_ir — function, 98 lines</title></rect>
+<rect x="545.0" y="2361.5" width="60.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.extractors.python.resolve.to_ir._point_at" data-kind="function" class="blk"><title>_point_at — function, 9 lines</title></rect>
+<rect x="638.0" y="2289.5" width="74.0" height="139.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.ir.validate — 278 lines</title></rect>
+<rect x="638.0" y="2310.5" width="74.0" height="2.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.ir.validate.IRError" data-kind="class" class="blk"><title>IRError — class, 2 lines</title></rect>
+<rect x="638.0" y="2312.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate._schema" data-kind="function" class="blk"><title>_schema — function, 2 lines</title></rect>
+<rect x="638.0" y="2314.5" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate._props" data-kind="function" class="blk"><title>_props — function, 5 lines</title></rect>
+<rect x="638.0" y="2318.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate._fields" data-kind="function" class="blk"><title>_fields — function, 4 lines</title></rect>
+<rect x="638.0" y="2321.0" width="74.0" height="54.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate.check" data-kind="function" class="blk"><title>check — function, 108 lines</title></rect>
+<rect x="638.0" y="2382.5" width="74.0" height="29.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate._check_larder" data-kind="function" class="blk"><title>_check_larder — function, 58 lines</title></rect>
+<rect x="638.0" y="2412.5" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate.validate" data-kind="function" class="blk"><title>validate — function, 6 lines</title></rect>
+<rect x="638.0" y="2416.5" width="74.0" height="11.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ir.validate.check_model_matches_schema" data-kind="function" class="blk"><title>check_model_matches_schema — function, 23 lines</title></rect>
+<rect x="720.0" y="2289.5" width="74.0" height="82.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.ir.model — 165 lines</title></rect>
+<rect x="720.0" y="2306.0" width="74.0" height="19.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.ir.model.Meta" data-kind="class" class="blk"><title>Meta — class, 38 lines</title></rect>
+<rect x="727.0" y="2316.0" width="60.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Meta.to_dict" data-kind="function" class="blk"><title>to_dict — function, 18 lines</title></rect>
+<rect x="720.0" y="2326.5" width="74.0" height="10.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.ir.model.Node" data-kind="class" class="blk"><title>Node — class, 21 lines</title></rect>
+<rect x="727.0" y="2331.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Node.__post_init__" data-kind="function" class="blk"><title>__post_init__ — function, 3 lines</title></rect>
+<rect x="727.0" y="2333.0" width="60.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Node.to_dict" data-kind="function" class="blk"><title>to_dict — function, 8 lines</title></rect>
+<rect x="720.0" y="2338.5" width="74.0" height="7.5" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.ir.model.Edge" data-kind="class" class="blk"><title>Edge — class, 15 lines</title></rect>
+<rect x="727.0" y="2342.5" width="60.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Edge.to_dict" data-kind="function" class="blk"><title>to_dict — function, 7 lines</title></rect>
+<rect x="720.0" y="2347.5" width="74.0" height="24.0" rx="2" fill="#1d4ed8" stroke="none" opacity="0.95" data-id="docgen.ir.model.Graph" data-kind="class" class="blk"><title>Graph — class, 48 lines</title></rect>
+<rect x="727.0" y="2352.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Graph.node" data-kind="function" class="blk"><title>node — function, 4 lines</title></rect>
+<rect x="727.0" y="2354.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Graph.edge" data-kind="function" class="blk"><title>edge — function, 4 lines</title></rect>
+<rect x="727.0" y="2357.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Graph.has" data-kind="function" class="blk"><title>has — function, 2 lines</title></rect>
+<rect x="727.0" y="2359.5" width="60.0" height="8.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Graph.to_dict" data-kind="function" class="blk"><title>to_dict — function, 16 lines</title></rect>
+<rect x="727.0" y="2368.5" width="60.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ir.model.Graph.from_dict" data-kind="function" class="blk"><title>from_dict — function, 6 lines</title></rect>
+<rect x="28.0" y="2468.5" width="74.0" height="242.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.ops.filter — 485 lines</title></rect>
+<rect x="28.0" y="2486.5" width="74.0" height="28.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter._rebuild" data-kind="function" class="blk"><title>_rebuild — function, 57 lines</title></rect>
+<rect x="35.0" y="2491.0" width="60.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ops.filter._rebuild.surviving_parent" data-kind="function" class="blk"><title>surviving_parent — function, 5 lines</title></rect>
+<rect x="35.0" y="2498.0" width="60.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ops.filter._rebuild.lift" data-kind="function" class="blk"><title>lift — function, 6 lines</title></rect>
+<rect x="28.0" y="2516.0" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.drop_kinds" data-kind="function" class="blk"><title>drop_kinds — function, 14 lines</title></rect>
+<rect x="28.0" y="2524.0" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.only_kinds" data-kind="function" class="blk"><title>only_kinds — function, 14 lines</title></rect>
+<rect x="28.0" y="2532.0" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.drop_stdlib" data-kind="function" class="blk"><title>drop_stdlib — function, 13 lines</title></rect>
+<rect x="28.0" y="2539.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.drop_external" data-kind="function" class="blk"><title>drop_external — function, 3 lines</title></rect>
+<rect x="28.0" y="2542.0" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.subtree" data-kind="function" class="blk"><title>subtree — function, 13 lines</title></rect>
+<rect x="28.0" y="2549.5" width="74.0" height="22.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.neighbourhood" data-kind="function" class="blk"><title>neighbourhood — function, 45 lines</title></rect>
+<rect x="28.0" y="2573.0" width="74.0" height="9.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.collapse_to_depth" data-kind="function" class="blk"><title>collapse_to_depth — function, 18 lines</title></rect>
+<rect x="35.0" y="2578.0" width="60.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ops.filter.collapse_to_depth.level" data-kind="function" class="blk"><title>level — function, 6 lines</title></rect>
+<rect x="28.0" y="2583.0" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.drop_builtins" data-kind="function" class="blk"><title>drop_builtins — function, 14 lines</title></rect>
+<rect x="28.0" y="2591.0" width="74.0" height="17.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.overview" data-kind="function" class="blk"><title>overview — function, 35 lines</title></rect>
+<rect x="28.0" y="2609.5" width="74.0" height="36.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.shape" data-kind="function" class="blk"><title>shape — function, 72 lines</title></rect>
+<rect x="35.0" y="2633.5" width="60.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ops.filter.shape.rank_of" data-kind="function" class="blk"><title>rank_of — function, 9 lines</title></rect>
+<rect x="28.0" y="2646.5" width="74.0" height="12.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.split" data-kind="function" class="blk"><title>split — function, 24 lines</title></rect>
+<rect x="28.0" y="2659.5" width="74.0" height="51.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.filter.classify" data-kind="function" class="blk"><title>classify — function, 102 lines</title></rect>
+<rect x="110.0" y="2468.5" width="74.0" height="191.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.ops.pages — 383 lines</title></rect>
+<rect x="110.0" y="2499.0" width="74.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.pages.slugify" data-kind="function" class="blk"><title>slugify — function, 8 lines</title></rect>
+<rect x="110.0" y="2504.0" width="74.0" height="4.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.pages._key" data-kind="function" class="blk"><title>_key — function, 8 lines</title></rect>
+<rect x="110.0" y="2509.0" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.pages._under" data-kind="function" class="blk"><title>_under — function, 5 lines</title></rect>
+<rect x="110.0" y="2512.5" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.pages._representative" data-kind="function" class="blk"><title>_representative — function, 13 lines</title></rect>
+<rect x="110.0" y="2520.0" width="74.0" height="33.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.pages.page_ir" data-kind="function" class="blk"><title>page_ir — function, 67 lines</title></rect>
+<rect x="110.0" y="2554.5" width="74.0" height="10.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.pages.layout" data-kind="function" class="blk"><title>layout — function, 20 lines</title></rect>
+<rect x="110.0" y="2565.5" width="74.0" height="30.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.pages.paginate" data-kind="function" class="blk"><title>paginate — function, 61 lines</title></rect>
+<rect x="117.0" y="2574.0" width="60.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ops.pages.paginate.unique" data-kind="function" class="blk"><title>unique — function, 6 lines</title></rect>
+<rect x="117.0" y="2577.5" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ops.pages.paginate.opens" data-kind="function" class="blk"><title>opens — function, 3 lines</title></rect>
+<rect x="117.0" y="2579.5" width="60.0" height="15.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.ops.pages.paginate.visit" data-kind="function" class="blk"><title>visit — function, 30 lines</title></rect>
+<rect x="110.0" y="2597.0" width="74.0" height="38.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.pages.paginate_tables" data-kind="function" class="blk"><title>paginate_tables — function, 76 lines</title></rect>
+<rect x="110.0" y="2636.0" width="74.0" height="14.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.pages.coverage" data-kind="function" class="blk"><title>coverage — function, 28 lines</title></rect>
+<rect x="110.0" y="2651.0" width="74.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.ops.pages.for_view" data-kind="function" class="blk"><title>for_view — function, 17 lines</title></rect>
+<rect x="210.0" y="2468.5" width="74.0" height="111.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.style.extract — 222 lines</title></rect>
+<rect x="210.0" y="2499.0" width="74.0" height="8.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract._values_from" data-kind="function" class="blk"><title>_values_from — function, 17 lines</title></rect>
+<rect x="210.0" y="2508.5" width="74.0" height="22.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract._normalise" data-kind="function" class="blk"><title>_normalise — function, 45 lines</title></rect>
+<rect x="210.0" y="2532.0" width="74.0" height="12.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract._svg_files" data-kind="function" class="blk"><title>_svg_files — function, 25 lines</title></rect>
+<rect x="210.0" y="2545.5" width="74.0" height="21.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract.harvest" data-kind="function" class="blk"><title>harvest — function, 43 lines</title></rect>
+<rect x="210.0" y="2568.0" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract.write" data-kind="function" class="blk"><title>write — function, 7 lines</title></rect>
+<rect x="210.0" y="2572.5" width="74.0" height="6.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.extract.summarise" data-kind="function" class="blk"><title>summarise — function, 13 lines</title></rect>
+<rect x="292.0" y="2468.5" width="74.0" height="105.5" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.style.tokens — 211 lines</title></rect>
+<rect x="292.0" y="2496.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens._top" data-kind="function" class="blk"><title>_top — function, 2 lines</title></rect>
+<rect x="292.0" y="2498.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens._mode" data-kind="function" class="blk"><title>_mode — function, 3 lines</title></rect>
+<rect x="292.0" y="2501.0" width="74.0" height="3.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens._luminance" data-kind="function" class="blk"><title>_luminance — function, 6 lines</title></rect>
+<rect x="292.0" y="2505.0" width="74.0" height="50.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens.derive" data-kind="function" class="blk"><title>derive — function, 101 lines</title></rect>
+<rect x="299.0" y="2527.0" width="60.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.style.tokens.derive.accent" data-kind="function" class="blk"><title>accent — function, 2 lines</title></rect>
+<rect x="292.0" y="2556.5" width="74.0" height="7.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens.geometry" data-kind="function" class="blk"><title>geometry — function, 14 lines</title></rect>
+<rect x="292.0" y="2564.5" width="74.0" height="3.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens.write" data-kind="function" class="blk"><title>write — function, 7 lines</title></rect>
+<rect x="292.0" y="2569.0" width="74.0" height="4.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.style.tokens.from_folder" data-kind="function" class="blk"><title>from_folder — function, 9 lines</title></rect>
+<rect x="392.0" y="2468.5" width="74.0" height="14.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen — 2 lines</title></rect>
+<rect x="492.0" y="2468.5" width="74.0" height="75.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.lab.pg_probe — 150 lines</title></rect>
+<rect x="492.0" y="2504.0" width="74.0" height="15.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.lab.pg_probe.probe" data-kind="function" class="blk"><title>probe — function, 30 lines</title></rect>
+<rect x="492.0" y="2526.0" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.lab.pg_probe._simplify" data-kind="function" class="blk"><title>_simplify — function, 3 lines</title></rect>
+<rect x="492.0" y="2528.5" width="74.0" height="12.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.lab.pg_probe.main" data-kind="function" class="blk"><title>main — function, 25 lines</title></rect>
+<rect x="592.0" y="2468.5" width="74.0" height="132.0" rx="2" fill="#141414" stroke="#333333" stroke-width="1"><title>docgen.notebook.spec — 264 lines</title></rect>
+<rect x="592.0" y="2496.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec._step" data-kind="function" class="blk"><title>_step — function, 4 lines</title></rect>
+<rect x="592.0" y="2499.5" width="74.0" height="54.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec.from_ir" data-kind="function" class="blk"><title>from_ir — function, 108 lines</title></rect>
+<rect x="599.0" y="2506.5" width="60.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.8" data-id="docgen.notebook.spec.from_ir._order" data-kind="function" class="blk"><title>_order — function, 5 lines</title></rect>
+<rect x="592.0" y="2554.5" width="74.0" height="10.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec.scaffold" data-kind="function" class="blk"><title>scaffold — function, 20 lines</title></rect>
+<rect x="592.0" y="2565.5" width="74.0" height="29.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec.merge" data-kind="function" class="blk"><title>merge — function, 58 lines</title></rect>
+<rect x="592.0" y="2595.5" width="74.0" height="2.0" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec.load" data-kind="function" class="blk"><title>load — function, 2 lines</title></rect>
+<rect x="592.0" y="2597.5" width="74.0" height="2.5" rx="2" fill="#15803d" stroke="none" opacity="0.95" data-id="docgen.notebook.spec.dump" data-kind="function" class="blk"><title>dump — function, 5 lines</title></rect>
 <text x="28" y="40" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen</text>
-<text x="28" y="1242" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen</text>
-<text x="210" y="1242" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.cli</text>
-<text x="28" y="1406" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.emitters</text>
-<text x="702" y="1406" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.extractors</text>
-<text x="28" y="1692" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.extractors</text>
-<text x="292" y="1692" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.book</text>
-<text x="638" y="1692" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.extractors.python</text>
-<text x="28" y="1920" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.ir</text>
-<text x="210" y="1920" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.style</text>
-<text x="392" y="1920" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">(root)</text>
-<text x="492" y="1920" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.lab</text>
-<text x="592" y="1920" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.notebook</text>
-<text x="692" y="1920" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.ops</text>
-<text x="28" y="1219" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">selftest</text>
+<text x="28" y="1466" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen</text>
+<text x="210" y="1466" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.emitters</text>
+<text x="28" y="1773" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.emitters</text>
+<text x="292" y="1773" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.cli</text>
+<text x="28" y="1938" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.cli</text>
+<text x="292" y="1938" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.book</text>
+<text x="28" y="2284" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.extractors</text>
+<text x="456" y="2284" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.extractors.python</text>
+<text x="638" y="2284" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.ir</text>
+<text x="28" y="2462" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.ops</text>
+<text x="210" y="2462" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.style</text>
+<text x="392" y="2462" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">(root)</text>
+<text x="492" y="2462" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.lab</text>
+<text x="592" y="2462" font-family="Helvetica,sans-Serif" font-size="10" font-weight="bold" fill="#a3a3a3">docgen.notebook</text>
+<text x="28" y="1442" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">selftest</text>
 <text x="110" y="213" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">book</text>
 <text x="192" y="152" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">style</text>
 <text x="274" y="109" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">reference</text>
-<text x="356" y="93" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">cli</text>
+<text x="356" y="95" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">cli</text>
 <text x="438" y="69" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">ops</text>
 <text x="520" y="69" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">notebook</text>
 <text x="602" y="69" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">emitters</text>
 <text x="684" y="69" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">lab</text>
 <text x="766" y="69" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">__main__</text>
-<text x="28" y="1271" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">ir</text>
-<text x="110" y="1271" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">extractors</text>
-<text x="210" y="1384" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">emit</text>
-<text x="292" y="1316" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">extract</text>
-<text x="374" y="1302" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">view</text>
-<text x="456" y="1297" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">common</text>
-<text x="538" y="1297" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">run</text>
-<text x="620" y="1294" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">book</text>
-<text x="702" y="1282" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">check</text>
-<text x="784" y="1274" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">validate</text>
-<text x="28" y="1668" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">site</text>
-<text x="110" y="1580" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">explore</text>
-<text x="192" y="1568" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">dot</text>
-<text x="274" y="1561" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">notebook</text>
-<text x="356" y="1560" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">minimap</text>
-<text x="438" y="1552" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">erd</text>
-<text x="520" y="1504" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">index</text>
-<text x="602" y="1454" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">auto</text>
-<text x="702" y="1562" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">code</text>
-<text x="784" y="1556" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">usage</text>
-<text x="28" y="1802" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">openapi</text>
-<text x="110" y="1787" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">db</text>
-<text x="192" y="1725" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">python</text>
-<text x="292" y="1897" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">build</text>
-<text x="374" y="1870" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">config</text>
-<text x="456" y="1844" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">checks</text>
-<text x="538" y="1804" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">larder</text>
-<text x="638" y="1824" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">collect</text>
-<text x="720" y="1798" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">resolve</text>
-<text x="28" y="2074" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">validate</text>
-<text x="110" y="2018" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">model</text>
-<text x="210" y="2046" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">extract</text>
-<text x="292" y="2040" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">tokens</text>
-<text x="392" y="1949" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">docgen</text>
-<text x="492" y="2010" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">pg_probe</text>
-<text x="592" y="2067" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">spec</text>
-<text x="692" y="2178" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">filter</text>
-<rect x="28" y="2217.5" width="9" height="9" rx="2" fill="#1a1a1a"/>
-<text x="41" y="2225.5" font-family="Helvetica,sans-Serif" font-size="9" fill="#666666">module</text>
-<rect x="86" y="2217.5" width="9" height="9" rx="2" fill="#1d4ed8"/>
-<text x="99" y="2225.5" font-family="Helvetica,sans-Serif" font-size="9" fill="#666666">class</text>
-<rect x="138" y="2217.5" width="9" height="9" rx="2" fill="#d4a574"/>
-<text x="151" y="2225.5" font-family="Helvetica,sans-Serif" font-size="9" fill="#666666">interface</text>
-<rect x="214" y="2217.5" width="9" height="9" rx="2" fill="#15803d"/>
-<text x="227" y="2225.5" font-family="Helvetica,sans-Serif" font-size="9" fill="#666666">function</text>
-<text x="858" y="2225.5" text-anchor="end" font-family="Helvetica,sans-Serif" font-size="9" fill="#666666">47 files · 10,350 lines · 1px ≈ 2.0 lines</text>
+<text x="28" y="1494" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">ir</text>
+<text x="110" y="1494" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">extractors</text>
+<text x="210" y="1750" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">site</text>
+<text x="292" y="1640" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">notebook</text>
+<text x="374" y="1638" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">explore</text>
+<text x="456" y="1635" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">dot</text>
+<text x="538" y="1620" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">minimap</text>
+<text x="620" y="1618" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">erd</text>
+<text x="702" y="1616" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">docsite</text>
+<text x="784" y="1562" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">index</text>
+<text x="28" y="1861" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">markdown</text>
+<text x="110" y="1848" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">paged</text>
+<text x="192" y="1820" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">auto</text>
+<text x="292" y="1914" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">emit</text>
+<text x="374" y="1848" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">extract</text>
+<text x="456" y="1838" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">run</text>
+<text x="538" y="1833" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">view</text>
+<text x="620" y="1832" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">scaffold</text>
+<text x="702" y="1828" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">common</text>
+<text x="784" y="1826" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">book</text>
+<text x="28" y="1982" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">check</text>
+<text x="110" y="1970" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">contract</text>
+<text x="192" y="1969" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">validate</text>
+<text x="292" y="2260" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">config</text>
+<text x="374" y="2177" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">document</text>
+<text x="456" y="2162" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">build</text>
+<text x="538" y="2142" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">checks</text>
+<text x="620" y="2050" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">larder</text>
+<text x="702" y="2034" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">notes</text>
+<text x="28" y="2440" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">code</text>
+<text x="110" y="2433" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">usage</text>
+<text x="192" y="2394" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">openapi</text>
+<text x="274" y="2379" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">db</text>
+<text x="356" y="2317" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">python</text>
+<text x="456" y="2416" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">collect</text>
+<text x="538" y="2390" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">resolve</text>
+<text x="638" y="2438" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">validate</text>
+<text x="720" y="2381" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">model</text>
+<text x="28" y="2720" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">filter</text>
+<text x="110" y="2669" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">pages</text>
+<text x="210" y="2588" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">extract</text>
+<text x="292" y="2583" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">tokens</text>
+<text x="392" y="2492" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">docgen</text>
+<text x="492" y="2552" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">pg_probe</text>
+<text x="592" y="2610" font-family="Helvetica,sans-Serif" font-size="7" fill="#666666">spec</text>
+<rect x="28" y="2760.0" width="9" height="9" rx="2" fill="#1a1a1a"/>
+<text x="41" y="2768.0" font-family="Helvetica,sans-Serif" font-size="9" fill="#666666">module</text>
+<rect x="86" y="2760.0" width="9" height="9" rx="2" fill="#1d4ed8"/>
+<text x="99" y="2768.0" font-family="Helvetica,sans-Serif" font-size="9" fill="#666666">class</text>
+<rect x="138" y="2760.0" width="9" height="9" rx="2" fill="#d4a574"/>
+<text x="151" y="2768.0" font-family="Helvetica,sans-Serif" font-size="9" fill="#666666">interface</text>
+<rect x="214" y="2760.0" width="9" height="9" rx="2" fill="#15803d"/>
+<text x="227" y="2768.0" font-family="Helvetica,sans-Serif" font-size="9" fill="#666666">function</text>
+<text x="858" y="2768.0" text-anchor="end" font-family="Helvetica,sans-Serif" font-size="9" fill="#666666">55 files · 13,028 lines · 1px ≈ 2.0 lines</text>
 </svg>
diff --git a/soleprint/atlas2/docgen/docs/index.html b/soleprint/atlas2/docgen/docs/index.html
index 4df16ab..9931fb6 100644
--- a/soleprint/atlas2/docgen/docs/index.html
+++ b/soleprint/atlas2/docgen/docs/index.html
@@ -19,12 +19,15 @@
     <a href="#what">What it is</a>
     <a href="#idea">The idea</a>
     <a href="#quick">Five minutes</a>
+    <a href="#first">Your first project</a>
+    <a href="#models">Working with a model</a>
 
     <div class="group">Architecture</div>
     <a href="#layers">The three concerns</a>
     <a href="#book">The book</a>
     <a href="#ir">The IR</a>
     <a href="#shape">Shape decides the drawing</a>
+    <a href="#pages">Pages</a>
 
     <div class="group">Reading</div>
     <a href="#extractors">Extractors</a>
@@ -37,11 +40,13 @@
     <a href="#emitters">Emitters</a>
     <a href="#explore">Explore</a>
     <a href="#notebooks">Notebooks</a>
+    <a href="#notes">Notes</a>
     <a href="#style">Style &amp; colour</a>
 
     <div class="group">Reference</div>
     <a href="#standalone">Standalone</a>
     <a href="#runs">Run files</a>
+    <a href="#projects">Project files</a>
     <a href="#commands">Commands</a>
     <a href="#deps">Dependencies</a>
     <a href="#testing">Testing</a>
@@ -154,6 +159,145 @@ make self                           <span class="c"># docgen's book of soleprint
   the outputs open over <code>file://</code>.
 </p>
 
+<!-- ─────────────────────────────────────────────────────────────── -->
+<h2 id="first">Your first project</h2>
+
+<p>
+  From nothing to a notebook and a site for a project of yours, with your own text
+  in the right places. docgen lives in its own folder, and the project only gets one
+  config file and, later, a folder of notes.
+</p>
+
+<h3>1. Put docgen somewhere and check the machine</h3>
+
+<pre><code>cp -r docgen ~/tools/docgen
+cd ~/tools/docgen
+make doctor          <span class="c"># what is installed; never fails</span>
+make sync            <span class="c"># optional: C#/TypeScript, OpenAPI, all from uv.lock</span></code></pre>
+
+<p>
+  From anywhere else, docgen runs as <code>python3 -m docgen</code> with its parent
+  folder on the path:
+</p>
+
+<pre><code>export PYTHONPATH=~/tools             <span class="c"># the folder that holds docgen/</span>
+python3 -m docgen --help</code></pre>
+
+<h3>2. Write <code>docgen.toml</code> at the project's root</h3>
+
+<pre><code>[project]
+name = "orders-service"
+
+[extract.code]
+root = "src"
+ext  = [".cs"]
+
+[emit.notebook]
+output = "../docs_out/orders_service_notebook"
+
+[emit.site]
+output = "../docs_out/orders_service_site"</code></pre>
+
+<p>
+  Paths are relative to this file. Keep the outputs outside the source tree. See
+  <a href="#projects">project files</a> for every key, and add
+  <code>.docgen/</code> to the project's <code>.gitignore</code>.
+</p>
+
+<h3>3. Check what it will do, then build</h3>
+
+<pre><code>cd ~/work/orders-service
+python3 -m docgen run docgen.toml --list      <span class="c"># resolved paths; builds nothing</span>
+python3 -m docgen run docgen.toml --check     <span class="c"># build, then check every book</span></code></pre>
+
+<pre><code>docgen.toml  —  1 book(s)
+  ok    code                        …/.docgen/orders-service/books/code
+  ok    orders-service (document)   …/.docgen/orders-service
+
+1 book(s) in 1 document built and checked</code></pre>
+
+<p>
+  A file docgen can't use is refused before anything is built, with every problem
+  listed at once and what to do about each. Open
+  <code>../docs_out/orders_service_site/index.html</code>: each book shows what
+  came in and what came out, and its pages click through from the overview.
+</p>
+
+<h3>4. Add your own text</h3>
+
+<pre><code>python3 -m docgen scaffold docgen.toml --list   <span class="c"># every spot a note can go</span>
+python3 -m docgen scaffold docgen.toml          <span class="c"># or: write an empty stub for each</span></code></pre>
+
+<p>
+  Pick a spot and write markdown into <code>notes/&lt;book&gt;/&lt;spot&gt;.md</code>,
+  for example <code>notes/code/overview.md</code> above the overview page. Rebuild
+  and it's there, in the notebook and on the site. Stubs you leave empty add
+  nothing.
+</p>
+
+<div class="note">
+  <b>If a note stops appearing</b>, the page it was filed under was probably
+  renamed, for instance a package that moved. The rebuild says so and
+  <code>--check</code> fails with the note's name. Rename the file to the new spot
+  (<code>scaffold --list</code> shows them) or delete it.
+</div>
+
+<h3>5. Rebuild whenever the code moves</h3>
+
+<p>
+  <code>python3 -m docgen run docgen.toml --check</code> again. A rebuild replaces
+  exactly what the last one wrote and never touches your notes or anything you
+  added to the output folders. <code>--only code</code> rebuilds one book while
+  you're writing its notes.
+</p>
+
+<!-- ─────────────────────────────────────────────────────────────── -->
+<h2 id="models">Working with a model</h2>
+
+<p>
+  A model can write the config and the notes. It shouldn't write anything else,
+  since every other file is generated. docgen ships the instructions to give it:
+</p>
+
+<pre><code>python3 -m docgen contract &gt; docgen-contract.md</code></pre>
+
+<p>
+  That file is <code>docs/models.md</code>, printed verbatim. It lists every key
+  docgen accepts and the extensions it reads, has rules like "never a credential"
+  and "don't guess page ids", and ends with a table that maps each error docgen
+  can produce to the fix. docgen's own suite checks it against the code, so it
+  can't quietly go out of date: a key the loader accepts but the doc doesn't
+  name, or an example in it that doesn't load, fails <code>make check</code>.
+</p>
+
+<h3>The loop</h3>
+
+<ol>
+  <li><b>Give it the project and the contract.</b> A digest of the project
+      (<code>distill</code>), plus <code>docgen-contract.md</code> as an
+      attachment rather than pasted. If replies go through <code>explode</code>,
+      attach its contract too: explode's says how to format the reply, docgen's
+      says what goes in the files.</li>
+  <li><b>Ask for <code>docgen.toml</code> first.</b> Unpack it, then run
+      <code>run docgen.toml --list</code>. If it's refused, paste the errors back
+      verbatim. Each one is in the contract's repair table.</li>
+  <li><b>Build once, then list the spots.</b> Run
+      <code>scaffold docgen.toml --list</code> and paste the output back. Page
+      names depend on the real directories, and a model that guesses them writes
+      notes that land nowhere.</li>
+  <li><b>Ask for notes for those spots.</b> Unpack, rebuild with
+      <code>--check</code>, and paste back any note reported as filed under a page
+      that doesn't exist.</li>
+</ol>
+
+<div class="note warn">
+  <b>What a model tends to write that docgen refuses.</b> In a dry run, a model
+  asked for a live database URL (with its password), a <code>seed</code> reader,
+  and shell, YAML and SQL files as code. All three are refused with a reason, and
+  the URL is never echoed in the error. The contract tells the model up front, but
+  the refusal is what makes it safe.
+</div>
+
 <!-- ─────────────────────────────────────────────────────────────── -->
 <h2 id="layers">The three concerns</h2>
 
@@ -641,6 +785,69 @@ python3 -m docgen view ir.json --shape          <span class="c"># what will this
     dark for everything that is not a declaration — imports, constants, prose.</figcaption>
 </figure>
 
+<!-- ─────────────────────────────────────────────────────────────── -->
+<h2 id="pages">Pages</h2>
+
+<p>
+  A notebook doesn't scroll a wide image sideways: it scales it down to the cell
+  width until the labels can't be read. Zooming and panning is a workaround for a
+  picture that holds too much. So a book's diagram is split into <b>pages</b>,
+  each drawn small enough to fit the column it's going into.
+</p>
+
+<pre><code>overview                 one box per top-level group, relationships lifted
+└── station              one box per child of station
+    └── station.tools    one box per child of station.tools, and so on</code></pre>
+
+<p>
+  Pages follow structure, never scissors. Slicing one large image cuts boxes and
+  edges at the seams, and a slice means nothing on its own. A page is a subsystem:
+  its boxes are the scope's children, and anything outside the scope that they
+  touch appears as a <em>context</em> box, collapsed to the branch it sits on. A
+  page still says what its subsystem reaches without drawing the rest of the tree.
+</p>
+
+<h3>Fitted by measuring, not estimating</h3>
+
+<p>
+  Whether a page fits depends on its labels, fonts and spacing, so an estimate from
+  node counts is wrong the moment the names are long. Each page is rendered and its
+  width read back. If a page is too wide top-to-bottom, it's drawn left-to-right,
+  since height is free in a notebook and width isn't. If it still doesn't fit
+  (a level of many peers with no smaller structure to split into), the page is
+  kept and flagged <em>too wide</em> in its caption and in the index. Never cut,
+  never dropped.
+</p>
+
+<p>
+  Measured on soleprint, whose module graph rendered at 14:1 as one picture: 69
+  pages, and at the site's 800px column the widest flagged page is 988px.
+  Schemas page differently: cards in columns capped to the width, grouped by
+  tables joined by foreign keys, so a schema grows downward instead of sideways.
+</p>
+
+<div class="note">
+  <b>Which pages exist doesn't depend on width</b>, only how each is laid out
+  does. A notebook column and a site column get the same pages, which is what lets
+  a <a href="#notes">note</a> filed under a page land in the same place in both.
+</div>
+
+<h3>Clicking through, on the site</h3>
+
+<p>
+  Every page is its own HTML file with the diagram <b>inline</b>, not in an
+  <code>&lt;img&gt;</code>, which swallows clicks. A box standing for a subsystem
+  opens that subsystem's page. A module box opens its section of the book's
+  reference page. A context box opens its own branch. Breadcrumbs lead back up.
+  The size is adjustable: <b>fit</b> scales to the column, <b>1:1</b> shows the
+  drawing at natural size with scrollbars, the choice is remembered, and
+  <b>full screen</b> opens the pan-and-zoom viewer.
+</p>
+<p>
+  A notebook can't follow a link inside an image, so it gets a <b>page index</b>
+  instead: every page, indented by depth, each a link to its figure.
+</p>
+
 <!-- ─────────────────────────────────────────────────────────────── -->
 <h2 id="explore">Explore</h2>
 
@@ -747,6 +954,56 @@ python3 -m docgen view ir.json --shape          <span class="c"># what will this
 <pre><code>python3 -m docgen emit notebook ir.json --scaffold overlay.json
 python3 -m docgen emit notebook ir.json --overlay overlay.json -o walkthrough.ipynb</code></pre>
 
+<!-- ─────────────────────────────────────────────────────────────── -->
+<h2 id="notes">Notes</h2>
+
+<p>
+  Generation alone gives a document that's never stale and never says anything a
+  parser couldn't work out. Prose is the part only a person adds, and it has to
+  survive every rebuild, so it can't live in the output. It lives in a
+  <b>notes folder</b>, one markdown file per spot, named after the page or step it
+  belongs above:
+</p>
+
+<pre><code>notes/
+├── _intro.md                   top of the document
+├── _end.md                     bottom of the document
+└── &lt;book&gt;/
+    ├── _intro.md               top of that book's part
+    ├── larder.md               above "what came in"
+    ├── overview.md             above the overview page
+    └── station.tools.md        above the page for station.tools</code></pre>
+
+<p>
+  To put text above a page, create the file named after it. No schema, no JSON,
+  no ids to look up. That's something a person or a model can do without reading
+  anything first. Local images in a note are embedded: as a cell attachment in the
+  notebook, as a data URI on the site.
+</p>
+
+<pre><code>make scaffold CONFIG=docgen.toml      <span class="c"># an empty stub for every spot, never overwriting</span></code></pre>
+
+<p>
+  <code>scaffold</code> lists the spots rather than making you guess them. A stub
+  is a single HTML comment and renders nothing, so scaffolding a hundred spots
+  changes the output not at all until one is filled in. Run it again after the
+  sources change and it only adds the new spots.
+</p>
+
+<div class="note warn">
+  <b>A note whose page is gone is reported, not dropped.</b> Renaming a package
+  renames its page, and the note filed under the old name has nowhere to land.
+  Discarding it quietly is how hand-written text goes stale without anyone
+  noticing, so it appears in the document ledger and fails the check level. It's
+  the same rule the notebook overlay follows.
+</div>
+
+<p>
+  The <a href="#notebooks">overlay</a> stays for what notes can't do: drop a
+  step, reorder, replace generated code. Notes are applied after the overlay, so a
+  step that moves takes its note with it.
+</p>
+
 <!-- ─────────────────────────────────────────────────────────────── -->
 <h2 id="style">Style &amp; colour</h2>
 
@@ -872,10 +1129,10 @@ make doctor
 
 <table>
   <tr><th>context</th><th>checks</th><th>skipped</th></tr>
-  <tr><td>in the repo, synced</td><td>287</td><td>—</td></tr>
-  <tr><td>copied out, bare <code>python3</code></td><td>270</td><td>tree-sitter, OpenAPI, the in-place case</td></tr>
-  <tr><td>copied out, synced</td><td>279</td><td>OpenAPI, the in-place case</td></tr>
-  <tr><td>copied out, synced, <code>DOCGEN_REFERENCE</code> set</td><td>286</td>
+  <tr><td>in the repo, synced</td><td>346</td><td>—</td></tr>
+  <tr><td>copied out, bare <code>python3</code></td><td>329</td><td>tree-sitter, OpenAPI, the in-place case</td></tr>
+  <tr><td>copied out, synced</td><td>338</td><td>OpenAPI, the in-place case</td></tr>
+  <tr><td>copied out, synced, <code>DOCGEN_REFERENCE</code> set</td><td>345</td>
       <td>the in-place case — correctly, there is no repo above</td></tr>
 </table>
 
@@ -973,6 +1230,80 @@ python3 -m docgen run docgen.toml --list        <span class="c"># resolved paths
   because those are data that tools write.
 </p>
 
+<!-- ─────────────────────────────────────────────────────────────── -->
+<h2 id="projects">Project files</h2>
+
+<p>
+  A run file lists independent books. A <b>project file</b> describes one
+  <em>document</em> built from several sources: an API contract and the code
+  behind it, a schema and the service that uses it. It's the shape a model wrote
+  unprompted in a dry run, so docgen reads it as written:
+</p>
+
+<pre><code><span class="c"># &lt;project&gt;/docgen.toml</span>
+[project]
+name  = "orders-api"
+title = "Orders API"
+notes = "notes"                     <span class="c"># default</span>
+build = ".docgen"                   <span class="c"># book artifacts, default; gitignore it</span>
+
+[extract.openapi]
+spec = "doc/contracts/openapi.yaml"
+
+[extract.code]
+root = "src"
+ext  = [".cs"]
+
+[ops]
+drop_stdlib   = true
+drop_builtins = true
+
+[emit.notebook]
+output = "../docs_out/orders_api_notebook"
+theme  = "lucid"
+
+[emit.site]
+output = "../docs_out/orders_api_site"
+width  = 800</code></pre>
+
+<p>
+  Each <code>[extract.*]</code> table is a <b>book</b>, and a book is a part of
+  every output rather than an output of its own. Each <code>[emit.*]</code> table
+  is an output made of all of them: one notebook and one site, each with a part
+  per book. Several sources of one kind use <code>[[extract.code]]</code> with a
+  <code>name</code> each. <code>[ops]</code> applies to every book's view before
+  paging.
+</p>
+<p>
+  Every part still opens with what came in and closes with what came out, and the
+  document opens with every larder and closes with every reconciliation. A book
+  that can't be built doesn't cost the others: the outputs are assembled from
+  what was built, and both say <em>this document is incomplete</em> and name what's
+  missing.
+</p>
+
+<h3>Refused, with what to do instead</h3>
+
+<table>
+  <tr><th>written</th><th>why not</th></tr>
+  <tr><td><code>[extract.db] url = …</code></td>
+      <td>docgen reads a schema dump and never connects, and a URL in a committed
+      file is a credential in a committed file. Write the schema with
+      <code>modelgen from-db</code>, then <code>schema = …</code>. The URL is never
+      repeated in the error.</td></tr>
+  <tr><td><code>ext = [".sh", ".yaml", ".sql"]</code></td>
+      <td>No grammar for those yet. The error names the extensions that are read.</td></tr>
+  <tr><td><code>[extract.seed]</code></td>
+      <td>No such reader. The error names the ones that exist.</td></tr>
+  <tr><td><code>[project]</code> and <code>[[book]]</code> in one file</td>
+      <td>Which one it meant is exactly what nobody should have to guess.</td></tr>
+</table>
+
+<p>
+  <code>docgen.project.example.toml</code> ships beside the run file example and
+  builds docgen's own fixtures into one document, with a sample note.
+</p>
+
 <!-- ─────────────────────────────────────────────────────────────── -->
 <h2 id="commands">Commands</h2>
 
@@ -981,7 +1312,9 @@ python3 -m docgen run docgen.toml --list        <span class="c"># resolved paths
   <tr><th>target</th><th>does</th></tr>
   <tr><td><code>make sync</code></td><td><code>.venv</code> with every optional group, from <code>uv.lock</code></td></tr>
   <tr><td><code>make book SRC=…</code></td><td><b>one whole operation</b>, measured at both ends</td></tr>
-  <tr><td><code>make run CONFIG=…</code></td><td>every book a <a href="#runs">run file</a> lists</td></tr>
+  <tr><td><code>make run CONFIG=…</code></td><td>every book a <a href="#runs">run file</a> lists, or a <a href="#projects">project</a>'s document</td></tr>
+  <tr><td><code>make scaffold CONFIG=…</code></td><td>an empty <a href="#notes">note</a> for every page and step</td></tr>
+  <tr><td><code>python3 -m docgen contract</code></td><td>the <a href="#models">instructions for a model</a> that writes the config and notes</td></tr>
   <tr><td><code>make check</code></td><td>docgen's own suite, offline, nothing installed</td></tr>
   <tr><td><code>make check BOOK=…</code></td><td>one book's own level — generated and custom</td></tr>
   <tr><td><code>make doctor</code></td><td>what this machine has and what it is missing</td></tr>
@@ -1028,6 +1361,10 @@ python3 -m docgen run docgen.toml --list        <span class="c"># resolved paths
 python3 -m docgen run docgen.toml                    <span class="c"># every book a run file lists</span>
 python3 -m docgen check                              <span class="c"># docgen's own suite</span>
 python3 -m docgen check out/book/slug                <span class="c"># that book's level</span>
+python3 -m docgen check .docgen/&lt;project&gt;            <span class="c"># a project document's level</span>
+python3 -m docgen scaffold docgen.toml               <span class="c"># stub notes for every spot</span>
+python3 -m docgen scaffold docgen.toml --list        <span class="c"># the spots, written nowhere</span>
+python3 -m docgen contract                           <span class="c"># the instructions for a model</span>
 
 python3 -m docgen extract python --root SRC -o ir.json
 python3 -m docgen extract code    --root SRC -o ir.json
@@ -1136,14 +1473,14 @@ make lock                              <span class="c"># after editing pyproject
   <tr><th>command</th><th>asks about</th><th>fails?</th></tr>
   <tr><td><code>make doctor</code></td><td>the machine — what is installed</td>
       <td>never; it reports</td></tr>
-  <tr><td><code>make check</code></td><td>docgen — 287 checks</td>
+  <tr><td><code>make check</code></td><td>docgen — 346 checks</td>
       <td>exit 1</td></tr>
-  <tr><td><code>make check BOOK=&lt;dir&gt;</code></td><td>that one book</td>
+  <tr><td><code>make check BOOK=&lt;dir&gt;</code></td><td>that one book, or a project's document</td>
       <td>exit 1</td></tr>
 </table>
 
 <p>
-  All 287 after <code>make sync</code>, 272 with nothing optional installed — the
+  All 346 after <code>make sync</code>, 331 with nothing optional installed — the
   suite skips rather than fails when tree-sitter, lxml or the OpenAPI reader is
   absent. See <a href="#standalone">standalone</a> for the counts outside the repo.
   Among them, two that keep this page's structure true: nothing outside
diff --git a/soleprint/atlas2/docgen/docs/models.md b/soleprint/atlas2/docgen/docs/models.md
new file mode 100644
index 0000000..d92e257
--- /dev/null
+++ b/soleprint/atlas2/docgen/docs/models.md
@@ -0,0 +1,259 @@
+# docgen — instructions for a model
+
+You are helping document a software project with **docgen**. docgen reads source
+artifacts (a code tree, a database schema dump, an OpenAPI document, a HAR recording)
+and generates a notebook and a website from them. You do not generate those outputs.
+You write the two kinds of file a person would otherwise write by hand:
+
+1. **`docgen.toml`**: which sources to read and which outputs to build.
+2. **Notes**: short markdown files that docgen places above a specific page or step.
+
+Everything else is generated, and anything you write into a generated file is
+overwritten on the next build.
+
+If your replies are unpacked by `explode`, its contract decides the reply format. This
+file decides only what goes in the files.
+
+---
+
+## Rules
+
+Follow all of these. A file that breaks one is refused when it is loaded, and the error
+is pasted back to you.
+
+1. **Use only the keys listed below, spelled exactly as listed.** Unknown keys are
+   refused, never ignored. Do not invent keys, readers or outputs.
+2. **Never put a database URL, password, token or any credential in any file.** docgen
+   does not connect to databases. It reads a schema file written by another tool.
+3. **Every path is relative to the `docgen.toml` file itself.**
+4. **Outputs must be outside every source tree** (`output = "../docs_out/..."` is the
+   usual choice). A build written inside a tree it reads is refused.
+5. **Only list file extensions docgen can read** (see `ext` below). If the project's
+   interesting files are shell scripts, YAML or SQL, leave them out and say so in a
+   note. docgen does not read them yet.
+6. **Do not guess page ids for notes.** Write a note only for a spot you were given,
+   either by the output of `docgen scaffold --list` or by the table in "Notes" below. A
+   note for a spot that does not exist fails the build's checks.
+7. **Notes say what the code cannot.** Why something exists, what it replaced, how it is
+   meant to be used, what to watch out for. Do not restate what the diagram already shows
+   (names, counts, which module imports which).
+8. If something you need to write a correct file is missing (the project's directory
+   layout, where the OpenAPI file is), ask for it instead of guessing.
+
+---
+
+## `docgen.toml` for one project
+
+One file at the project root. It describes one **document** built from several sources.
+Each `[extract.*]` table is a **book**, one part of the document. Each `[emit.*]` table
+is an output that contains every book.
+
+```toml
+[project]
+name  = "orders-service"
+title = "Orders Service"
+
+[extract.openapi]
+spec = "doc/contracts/openapi.yaml"
+
+[extract.code]
+root = "src"
+ext  = [".cs"]
+
+[ops]
+drop_stdlib   = true
+drop_builtins = true
+
+[emit.notebook]
+output = "../docs_out/orders_service_notebook"
+theme  = "lucid"
+
+[emit.site]
+output = "../docs_out/orders_service_site"
+```
+
+### `[project]`
+
+| key | required | value |
+|---|---|---|
+| `name` | yes | letters, digits, `.`, `_`, `-`; starts with a letter or digit |
+| `title` | no | any text; defaults to `name` |
+| `notes` | no | folder of notes; default `"notes"` |
+| `build` | no | where intermediate files go; default `".docgen"` (should be gitignored) |
+| `reference` | no | path to the spr repository; needed only to read OpenAPI |
+
+### `[extract.<reader>]`: the sources
+
+| reader | required key | optional keys | reads |
+|---|---|---|---|
+| `python` | `root` (a directory) | `name`, `exclude`, `overlay` | Python, with imports and inheritance |
+| `code` | `root` (a directory) | `name`, `ext`, `exclude`, `overlay` | C#, TypeScript, Python structure (no edges) |
+| `db` | `schema` (a file) | `name`, `overlay` | a schema JSON dump, as `modelgen from-db` writes |
+| `openapi` | `spec` (a file) | `name`, `overlay` | an OpenAPI document |
+| `usage` | `har` (a file) | `name`, `overlay` | a HAR recording of real API traffic |
+
+- `ext`: a list chosen from `".cs"`, `".ts"`, `".tsx"`, `".mts"`, `".py"`. Nothing else.
+- `exclude`: a list of directory names to skip, e.g. `["tests", "migrations"]`.
+- `name`: the book's name. It defaults to the reader's name. Use `[[extract.<reader>]]`
+  (double brackets) with a different `name` in each table to read two trees of the same
+  kind:
+
+```toml
+[project]
+name = "storefront"
+
+[[extract.code]]
+name = "backend"
+root = "src"
+ext  = [".cs"]
+
+[[extract.code]]
+name = "frontend"
+root = "web/src"
+ext  = [".ts", ".tsx"]
+
+[emit.site]
+output = "../docs_out/storefront_site"
+```
+
+### `[ops]`: applied to every book before drawing
+
+| key | value |
+|---|---|
+| `drop_stdlib` | `true` removes standard-library imports |
+| `drop_builtins` | `true` removes built-in names |
+| `drop_external` | `true` removes every name the source does not define |
+| `only` | a list of kinds to keep |
+| `drop` | a list of kinds to remove |
+
+Kinds: `module`, `class`, `interface`, `function`, `external`, `table`, `column`,
+`endpoint`, `operation`.
+
+### `[emit.<output>]`: the outputs
+
+The outputs are `notebook` and `site`, nothing else.
+
+| key | required | value |
+|---|---|---|
+| `output` | yes | a directory. A notebook output may also be a path ending in `.ipynb` |
+| `theme` | no | `"dark"` (default) or `"lucid"` (light, for print) |
+| `style` | no | `"lucid"` (default) |
+| `width` | no | pixels a diagram page must fit; default 960 for a notebook, 800 for a site |
+
+---
+
+## `docgen.toml` for many independent books
+
+A different shape, for a list of unrelated books with one output folder each. Use it
+only when asked. A file may not contain both `[project]` and `[[book]]`.
+
+```toml
+[defaults]
+out     = "../docs_out"
+exclude = ["tests"]
+
+[[book]]
+name = "billing"
+root = "src"
+
+[[book]]
+name   = "schema"
+schema = "schema/schema.json"
+```
+
+| where | keys |
+|---|---|
+| top level | `reference`, `defaults`, `book` |
+| `[defaults]` | `out`, `style`, `theme`, `exclude`, `reader`, `notes` |
+| `[[book]]` | `name`, exactly one of `root` / `schema` / `openapi` / `har`, and optionally `reader` (`"python"` or `"code"`, only with `root`), `out`, `style`, `theme`, `exclude`, `overlay`, `notes` |
+
+A book's own value replaces the default for that key. Values are never merged.
+
+---
+
+## Notes
+
+A note is a markdown file. docgen puts its content directly above the spot it is named
+after, in both the notebook and the site. Its path is:
+
+```
+<notes>/_intro.md                    top of the whole document
+<notes>/_end.md                      end of the whole document
+<notes>/<book>/_intro.md             top of that book's part
+<notes>/<book>/<spot>.md             above that spot in the book
+```
+
+`<book>` is the book's `name` (the reader's name if none was given).
+
+### Spots every book has
+
+| spot | appears above |
+|---|---|
+| `larder` | "what came in": what was read |
+| `pages` | the index of diagram pages |
+| `overview` | the first diagram page |
+| `book` | "what came out": the closing summary |
+| `step-ir`, `step-view`, `step-pages`, `step-graph`, `step-index`, `step-sidebar`, `step-minimap`, `step-explore` | each intermediate step |
+
+### Spots that depend on the source
+
+- **Pages of a code tree**: named by a package's or directory's dotted path from the
+  root, for example `billing.invoices`. Not every directory gets a page: a level that
+  holds a single group is merged into it, and the top page is always `overview`.
+- **Pages of a schema**: `overview`, then `tables-01`, `tables-02`, …
+- **An API** (`openapi`, `usage`): `setup`, `client`, `shapes`, and one spot per call:
+  the method and path with every character outside letters, digits, `.`, `_` and `-`
+  replaced by `-`. So `GET /orders/{orderId}/lines` becomes `GET-orders-orderId-lines`.
+
+Page ids for a code tree depend on the actual directories. **Do not derive them yourself
+unless you have the full directory listing.** Ask for the output of:
+
+```
+python3 -m docgen scaffold docgen.toml --list
+```
+
+It prints every spot that exists, one per line.
+
+### Writing a note
+
+- Plain markdown: headings, paragraphs, lists, **bold**, *italic*, `code`, fenced code
+  blocks, links, tables, quotes.
+- No raw HTML. It is shown as text.
+- Images: a path relative to the note file, e.g. `![flow](../img/flow.svg)`. They are
+  embedded.
+- Keep it short: a few paragraphs. Start with `##` headings, because the page already
+  has its own title.
+- A note that contains only the stub comment docgen writes renders nothing. Write below
+  the comment, or replace the file's contents.
+
+Example: `notes/code/billing.invoices.md`:
+
+```markdown
+## Why invoices are immutable
+
+An invoice is never edited after it is issued. Corrections are a new credit note that
+references it. This is a legal requirement, not a design preference, so do not add
+update endpoints here.
+
+Start reading at `InvoiceIssuer`. It is the only place an invoice is created.
+```
+
+---
+
+## When the build refuses your file
+
+The person running docgen pastes the errors back. Each one says what to change:
+
+| error contains | fix |
+|---|---|
+| `has unknown key 'x'` | remove the key or use a listed one; check the spelling |
+| `docgen reads a schema dump and never connects` | remove `url`; use `schema = "path/to/schema.json"` |
+| `no grammar for .sh` | remove those extensions from `ext` |
+| `no reader named 'x'` | use one of `python`, `code`, `db`, `openapi`, `usage` |
+| `no output named 'x'` | use `notebook` or `site` |
+| `is inside the tree it reads` | move `output` or `build` outside the source directory |
+| `needs a name when there are several` | give each `[[extract.x]]` table a different `name` |
+| `must name exactly one source` | a `[[book]]` needs exactly one of `root`, `schema`, `openapi`, `har` |
+| `is not a directory` / `is not a file` | the path is wrong; ask for the real layout |
+| `note … belongs above 'x', which book 'y' no longer has` | that spot does not exist: rename the note to a listed spot, or delete it |
+| `both [project] and [[book]]` | use one shape per file |
diff --git a/soleprint/atlas2/docgen/emitters/docsite.py b/soleprint/atlas2/docgen/emitters/docsite.py
new file mode 100644
index 0000000..cc902dc
--- /dev/null
+++ b/soleprint/atlas2/docgen/emitters/docsite.py
@@ -0,0 +1,269 @@
+"""
+A document's site: an index of books, and every book as pages you click through.
+
+    site/
+    ├── index.html               every book, with what came in and what came out
+    ├── site.css  viewer.html
+    └── <book>/
+        ├── overview.html        the book's top page
+        ├── <page>.html          one subsystem each; its boxes open the next level
+        ├── <page>.svg           the same drawing, for the full-screen viewer
+        └── reference.html       every module with its docstring — where a leaf opens
+
+## Inline, so the boxes are links
+
+The single-page site put its diagram in an `<img>`, and an image swallows every
+click. Here the SVG is inlined, so a box that stands for a subsystem opens that
+subsystem's page, a box for a module opens its section of the reference page,
+and a context box — something outside this subsystem — opens its own branch.
+Breadcrumbs lead back up.
+
+## Adjustable
+
+A page is drawn to fit the content column, so it reads without zooming. The size
+is still the reader's: `fit` scales to the column, `1:1` shows the drawing at its
+natural size with scrollbars, and the choice is remembered. `full screen` opens
+the pan-and-zoom viewer for anything still too dense.
+
+This writes HTML and nothing else. What goes on each page, the links and the
+notes are prepared by `book/document.py` and handed in as data — an emitter has
+never heard of a book's extractor, and this one has not either.
+"""
+
+from html import escape
+from pathlib import Path
+
+from .markdown import to_html
+from .paged import inline
+from .site import CONTENT_W, CSS, SIDEBAR_W, VIEWER, _fill, _ledger, _slots
+from .site import emit as reference_page
+
+CONTENT_WIDTH = CONTENT_W
+
+SIZE_SCRIPT = """<script>
+// fit | 1:1 — a choice that sticks, because a reader who wants 1:1 on one page
+// wants it on the next. No dependency, no build step.
+(function () {
+  var key = 'docgen.size';
+  function set(mode) {
+    document.querySelectorAll('.fig').forEach(function (f) {
+      f.classList.toggle('actual', mode === 'actual');
+    });
+    document.querySelectorAll('.figbar button[data-size]').forEach(function (b) {
+      b.classList.toggle('on', b.dataset.size === mode);
+    });
+    try { localStorage.setItem(key, mode); } catch (e) {}
+  }
+  document.querySelectorAll('.figbar button[data-size]').forEach(function (b) {
+    b.addEventListener('click', function () { set(b.dataset.size); });
+  });
+  var saved = 'fit';
+  try { saved = localStorage.getItem(key) || 'fit'; } catch (e) {}
+  set(saved);
+})();
+</script>"""
+
+
+def _note(note, cls="note") -> str:
+    if not note:
+        return ""
+    text, uris = note
+    return f'<div class="{cls}">' + to_html(
+        text, image=lambda alt, src: f'<img src="{escape(uris.get(src, src))}" alt="{escape(alt)}">'
+    ) + "</div>"
+
+
+def _missing(failed: dict | None) -> str:
+    """Books that were meant to be here and are not. Above the ones that are,
+    because a reader who does not see this has no way to know the site is short."""
+    if not failed:
+        return ""
+    items = "".join(f"<li><code>{escape(name)}</code> — {escape(why)}</li>"
+                    for name, why in sorted(failed.items()))
+    return ('<div class="gap"><b>This document is incomplete.</b> '
+            f"{len(failed)} book(s) could not be built, so they are not below.<ul>{items}</ul></div>")
+
+
+def _tree(pages: list[dict], current: str | None) -> str:
+    by_parent: dict = {}
+    for p in pages:
+        by_parent.setdefault(p["parent"], []).append(p)
+    root = pages[0]["id"] if pages else None
+
+    def walk(page, depth):
+        active = ' class="active"' if page["slug"] == current else ""
+        link = f'<a href="{escape(page["slug"])}.html"{active}>{escape(page["title"])}</a>'
+        kids = by_parent.get(page["id"], [])
+        if not kids:
+            return f"<li>{link}</li>"
+        return f"<li>{link}<ul>" + "".join(walk(k, depth + 1) for k in kids) + "</ul></li>"
+
+    return "<ul>" + "".join(walk(p, 0) for p in pages if p["id"] == root) + "</ul>"
+
+
+def _page(title: str, book: dict, page: dict, svg: str | None, pages: list[dict],
+          note, doc_title: str) -> str:
+    b = book["book"]
+    by_id = {p["id"]: p for p in pages}
+    trail, cur = [], page
+    while cur is not None:
+        trail.append(cur)
+        cur = by_id.get(cur["parent"]) if cur.get("parent") else None
+    crumbs = [f'<a href="../index.html">{escape(doc_title)}</a>']
+    for p in reversed(trail):
+        if p is page:
+            crumbs.append(escape(p["title"]))
+        else:
+            crumbs.append(f'<a href="{escape(p["slug"])}.html">{escape(p["title"])}</a>')
+
+    from ..book.document import caption  # noqa: F401 - kept out of module import time
+    cap = caption(page)
+    warn = " warn" if page.get("too_wide") else ""
+    if svg is not None:
+        figure = (
+            '<div class="figbar"><button data-size="fit">fit</button>'
+            '<button data-size="actual">1:1</button>'
+            f'<a href="../viewer.html?src={escape(b.slug)}/{escape(page["slug"])}.svg">full screen</a>'
+            "</div>"
+            f'<div class="fig">{inline(svg)}</div>'
+        )
+    else:
+        figure = '<p class="caption warn">Not drawn — Graphviz is not installed here.</p>'
+
+    children = ""
+    if page.get("children"):
+        items = "".join(
+            f'<li><a href="{escape(by_id[c]["slug"])}.html">{escape(by_id[c]["title"])}</a></li>'
+            for c in page["children"] if c in by_id
+        )
+        children = f"<h3>Opens into</h3><ul class=\"children\">{items}</ul>"
+
+    return f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>{escape(page["title"])} — {escape(b.slug)} — {escape(doc_title)}</title>
+<link rel="stylesheet" href="../site.css">
+</head>
+<body>
+<div class="layout">
+  <nav class="sidebar">
+    <div class="sidebar-header"><b>{escape(b.slug)}</b><small>{escape(doc_title)}</small></div>
+    {_tree(pages, page["slug"])}
+    <ul>
+      <li><a href="reference.html">reference</a></li>
+      <li><a href="explore/explore.html">explore</a></li>
+      <li><a href="../index.html">all books</a></li>
+    </ul>
+  </nav>
+  <main class="content">
+    <div class="crumbs">{" › ".join(crumbs)}</div>
+    <h1>{escape(page["title"])}</h1>
+    {_note(note)}
+    {figure}
+    <p class="caption{warn}">{escape(cap)}</p>
+    {children}
+  </main>
+</div>
+{SIZE_SCRIPT}
+</body>
+</html>
+"""
+
+
+def write(out_dir, style, *, title: str, books: list[dict], intro=None, end=None,
+          failed: dict | None = None) -> list[Path]:
+    """Write the site. Returns every file written, for the output manifest.
+
+    `books` is a list of::
+
+        {"book": Book, "pages": [(page, svg)], "notes": {slug: (markdown, {ref: data uri})},
+         "intro": (markdown, {}) or None}
+    """
+    import shutil
+
+    out_dir = Path(out_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    values = _slots(style)
+    written: list[Path] = []
+
+    def put(path: Path, text: str):
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(text)
+        written.append(path)
+
+    put(out_dir / "site.css",
+        _fill(CSS.replace("__SIDEBAR__", str(SIDEBAR_W)).replace("__CONTENT__", str(CONTENT_W)),
+              values))
+    put(out_dir / "viewer.html", _fill(VIEWER.replace("__TITLE__", escape(title)), values))
+
+    cards, nav = [], []
+    for entry in books:
+        b = entry["book"]
+        pages = [p for p, _ in entry["pages"]]
+        book_dir = out_dir / b.slug
+        for page, svg in entry["pages"]:
+            put(book_dir / f"{page['slug']}.html",
+                _page(title, entry, page, svg, pages, entry["notes"].get(page["slug"]), title))
+            if svg is not None:
+                put(book_dir / f"{page['slug']}.svg", svg)
+
+        # The reference page: the single-page site as it was, one per book, where
+        # a module box on any page opens its own section.
+        ref = reference_page(b.view, style, title=f"{b.slug} — reference")["index.html"]
+        ref = ref.replace('href="site.css"', 'href="../site.css"')
+        put(book_dir / "reference.html", ref)
+
+        explore = b.out / "explore"
+        if explore.is_dir():
+            for f in sorted(explore.rglob("*")):
+                if f.is_file():
+                    target = book_dir / "explore" / f.relative_to(explore)
+                    target.parent.mkdir(parents=True, exist_ok=True)
+                    shutil.copyfile(f, target)
+                    written.append(target)
+
+        first = pages[0]["slug"] if pages else "reference"
+        too_wide = sum(1 for p in pages if p.get("too_wide"))
+        cards.append(
+            f'<div class="bookcard"><h2><a href="{escape(b.slug)}/{escape(first)}.html">'
+            f"{escape(b.slug)}</a></h2>"
+            + _note(entry.get("intro"))
+            + _ledger(b.to_dict())
+            + '<div class="links">'
+            + f'<a href="{escape(b.slug)}/{escape(first)}.html">{len(pages)} page(s)</a>'
+            + f'<a href="{escape(b.slug)}/reference.html">reference</a>'
+            + (f'<a href="{escape(b.slug)}/explore/explore.html">explore</a>' if explore.is_dir() else "")
+            + (f'<span class="caption warn">{too_wide} too wide</span>' if too_wide else "")
+            + "</div></div>"
+        )
+        nav.append(f'<li><a href="{escape(b.slug)}/{escape(first)}.html">{escape(b.slug)}</a></li>')
+
+    put(out_dir / "index.html", f"""<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="UTF-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>{escape(title)}</title>
+<link rel="stylesheet" href="site.css">
+</head>
+<body>
+<div class="layout">
+  <nav class="sidebar">
+    <div class="sidebar-header"><b>{escape(title)}</b><small>{len(books)} book(s)</small></div>
+    <ul>{"".join(nav)}</ul>
+  </nav>
+  <main class="content">
+    <h1>{escape(title)}</h1>
+    <p class="lede">Regenerated, not edited. Each book opens with what came in and what came out.</p>
+    {_note((intro, {}) if intro else None)}
+    {_missing(failed)}
+    <div class="books">{"".join(cards)}</div>
+    {_note((end, {}) if end else None)}
+  </main>
+</div>
+</body>
+</html>
+""")
+    return written
diff --git a/soleprint/atlas2/docgen/emitters/dot.py b/soleprint/atlas2/docgen/emitters/dot.py
index 0e4f2c7..bc4915b 100644
--- a/soleprint/atlas2/docgen/emitters/dot.py
+++ b/soleprint/atlas2/docgen/emitters/dot.py
@@ -59,7 +59,7 @@ def _style_words(rule: dict, *, filled: bool = True) -> str:
     return ",".join(words)
 
 
-def _node_attrs(node, rule: dict, style) -> dict:
+def _node_attrs(node, rule: dict, style, links: dict | None = None) -> dict:
     a = {
         "label": node.get("label") or node["id"],
         "shape": rule.get("shape", "box"),
@@ -76,7 +76,16 @@ def _node_attrs(node, rule: dict, style) -> dict:
         "class": node["kind"],
     }
     attrs = node.get("attrs") or {}
-    if attrs.get("file"):
+    if links and node["id"] in links:
+        # A link the caller supplied wins over the source anchor: on a paginated
+        # site a box is a way into its own page, which is worth more than the
+        # file it came from.
+        a["href"] = links[node["id"]]
+        a["tooltip"] = attrs.get("doc") or f"open {node['id']}"
+    elif attrs.get("file") and links is None:
+        # Only when the output is not managing links itself. A relative source
+        # path is a dead link on a web page, so an output that passes `links` —
+        # even an empty one — owns every href in the drawing.
         line = attrs.get("line")
         a["href"] = f"{attrs['file']}#L{line}" if line else attrs["file"]
         a["tooltip"] = attrs.get("doc") or node["id"]
@@ -86,8 +95,14 @@ def _node_attrs(node, rule: dict, style) -> dict:
 
 
 def emit(ir: dict, style, *, max_depth: int | None = None,
-         rankdir: str | None = None) -> str:
-    """IR document (a dict) + Style -> DOT text."""
+         rankdir: str | None = None, links: dict | None = None) -> str:
+    """IR document (a dict) + Style -> DOT text.
+
+    `links` maps node ids to URLs and becomes each box's `href` in the SVG.
+    Passed in rather than read from the IR, because where a box leads is a fact
+    about the output — a site page, a notebook anchor — and the IR is the same
+    for every output. Same rule that keeps colour out of it.
+    """
     nodes = {n["id"]: n for n in ir["nodes"]}
     children: dict[str | None, list[str]] = {}
     for n in ir["nodes"]:
@@ -119,7 +134,7 @@ def emit(ir: dict, style, *, max_depth: int | None = None,
         pad = "  " * (depth + 1)
 
         if not kids or too_deep:
-            out.append(f"{pad}{_q(node_id)}{_attrs(_node_attrs(node, style.node(node['kind']), style))}")
+            out.append(f"{pad}{_q(node_id)}{_attrs(_node_attrs(node, style.node(node['kind']), style, links))}")
             return
 
         rule = style.group(node["kind"])
@@ -138,6 +153,8 @@ def emit(ir: dict, style, *, max_depth: int | None = None,
         out.append(f'{pad}  labeljust=l')
         out.append(f'{pad}  id="{_esc(node_id)}"')
         out.append(f'{pad}  class="{node["kind"]}"')
+        if links and node_id in links:
+            out.append(f'{pad}  href="{_esc(links[node_id])}"')
         for kid in kids:
             write(kid, depth + 1)
         out.append(f"{pad}}}")
diff --git a/soleprint/atlas2/docgen/emitters/erd.py b/soleprint/atlas2/docgen/emitters/erd.py
index d736c1f..86450d3 100644
--- a/soleprint/atlas2/docgen/emitters/erd.py
+++ b/soleprint/atlas2/docgen/emitters/erd.py
@@ -84,7 +84,19 @@ def _card_height(table: dict, columns: bool = True) -> int:
     return header + (len(table["fields"]) * FIELD_H if columns else 0)
 
 
-def layout(tables: list[dict], edges: list[dict], columns: bool = True) -> dict[str, tuple[int, int]]:
+def max_columns(width_px: int) -> int:
+    """How many card columns fit a width budget given in CSS pixels.
+
+    The SVG is written in points (`width="Npt"`), and a browser draws a point as
+    4/3 of a pixel — so the budget is converted before dividing, or a page sized
+    for 960px renders at 1280px and the notebook shrinks it after all.
+    """
+    usable = width_px * 0.75 - 2 * PAD + COL_GAP
+    return max(1, int(usable // (CARD_W + COL_GAP)))
+
+
+def layout(tables: list[dict], edges: list[dict], columns: bool = True,
+           max_cols: int | None = None) -> dict[str, tuple[int, int]]:
     """Place cards in √n columns, referenced tables first.
 
     Sorting by "is the target of a foreign key" puts the tables everything
@@ -95,6 +107,10 @@ def layout(tables: list[dict], edges: list[dict], columns: bool = True) -> dict[
     ordered = sorted(tables, key=lambda t: (t["id"] not in referenced, t["id"]))
 
     cols = max(2, int((len(ordered) * 1.2) ** 0.5 + 0.999))
+    if max_cols is not None:
+        # Capped, not chosen: the page grows downward instead, which a notebook
+        # scrolls and does not shrink.
+        cols = max(1, min(cols, max_cols))
     col_w = CARD_W + COL_GAP
     cursor = [PAD] * cols
 
@@ -111,7 +127,7 @@ def _field_y(table: dict, index: int, top: int) -> float:
     return top + header + (max(index, 0) + 0.5) * FIELD_H
 
 
-def emit(ir: dict, style, *, columns: bool = True) -> str:
+def emit(ir: dict, style, *, columns: bool = True, width: int | None = None) -> str:
     """IR (a db document) + Style -> SVG text.
 
     `columns=False` draws the header of every card and none of its contents —
@@ -127,7 +143,7 @@ def emit(ir: dict, style, *, columns: bool = True) -> str:
         )
     edges = [e for e in ir["edges"] if e["kind"] in ("foreign_key", "references")]
     by_id = {t["id"]: t for t in tables}
-    pos = layout(tables, edges, columns)
+    pos = layout(tables, edges, columns, max_cols=max_columns(width) if width else None)
 
     s = style.slot
     width = max(x for x, _ in pos.values()) + CARD_W + PAD
diff --git a/soleprint/atlas2/docgen/emitters/markdown.py b/soleprint/atlas2/docgen/emitters/markdown.py
new file mode 100644
index 0000000..767cd78
--- /dev/null
+++ b/soleprint/atlas2/docgen/emitters/markdown.py
@@ -0,0 +1,145 @@
+"""
+Markdown -> HTML, for notes on the site. Stdlib only, and deliberately small.
+
+A notebook renders markdown itself, so notes go into it as written. The site has
+no renderer, and adding a dependency to turn a few paragraphs into HTML would
+break the rule that the structural path is the stdlib. So this covers what notes
+are actually written with:
+
+    # headings            paragraphs            - bullet / 1. numbered lists
+    **bold** *italic*     `code`                ```fenced code```
+    [links](url)          ![images](src)        | pipe | tables |
+    > quotes              ---
+
+Anything it does not recognise is **escaped, not passed through** — a note is
+text, and raw HTML in it is shown rather than executed.
+"""
+
+import re
+from html import escape
+
+
+def _url(raw: str) -> str:
+    """An attribute-safe URL. The text around it is already escaped without
+    quotes, so a `"` here would close the attribute; and a `javascript:` link is
+    refused outright — a note is text, not a place to run code."""
+    if re.match(r"^\s*(javascript|vbscript|data):", raw, re.I):
+        return "#"
+    return raw.replace('"', "&quot;")
+
+
+INLINE = [
+    (re.compile(r"!\[([^\]]*)\]\(([^)\s]+)\)"), lambda m, img: img(m.group(1), m.group(2))),
+    (re.compile(r"\[([^\]]+)\]\(([^)\s]+)\)"),
+     lambda m, img: f'<a href="{_url(m.group(2))}">{m.group(1)}</a>'),
+    (re.compile(r"\*\*(.+?)\*\*"), lambda m, img: f"<strong>{m.group(1)}</strong>"),
+    (re.compile(r"(?<![*\w])\*(?!\s)(.+?)(?<!\s)\*(?![*\w])"), lambda m, img: f"<em>{m.group(1)}</em>"),
+]
+
+
+def _inline(text: str, image) -> str:
+    # Code spans first and protected, so nothing inside them is formatted.
+    spans: list[str] = []
+
+    def keep(m):
+        spans.append(f"<code>{escape(m.group(1))}</code>")
+        return f"\x00{len(spans) - 1}\x00"
+
+    text = re.sub(r"`([^`]+)`", keep, text)
+    text = escape(text, quote=False)
+    for pattern, render in INLINE:
+        text = pattern.sub(lambda m: render(m, image), text)
+    return re.sub(r"\x00(\d+)\x00", lambda m: spans[int(m.group(1))], text)
+
+
+def to_html(text: str, *, image=None) -> str:
+    """Render a note. `image(alt, src) -> html` lets the caller embed local images."""
+    image = image or (lambda alt, src: f'<img src="{_url(src)}" alt="{alt.replace(chr(34), "&quot;")}">')
+    lines = text.replace("\r\n", "\n").split("\n")
+    out: list[str] = []
+    i = 0
+
+    def para(buf):
+        if buf:
+            out.append(f"<p>{_inline(' '.join(s.strip() for s in buf), image)}</p>")
+
+    buf: list[str] = []
+    while i < len(lines):
+        line = lines[i]
+        stripped = line.strip()
+
+        if stripped.startswith("```"):
+            para(buf); buf = []
+            code = []
+            i += 1
+            while i < len(lines) and not lines[i].strip().startswith("```"):
+                code.append(lines[i])
+                i += 1
+            out.append(f"<pre><code>{escape(chr(10).join(code))}</code></pre>")
+            i += 1
+            continue
+
+        if not stripped:
+            para(buf); buf = []
+            i += 1
+            continue
+
+        m = re.match(r"^(#{1,6})\s+(.*)$", stripped)
+        if m:
+            para(buf); buf = []
+            level = len(m.group(1))
+            out.append(f"<h{level}>{_inline(m.group(2), image)}</h{level}>")
+            i += 1
+            continue
+
+        if re.match(r"^(-{3,}|\*{3,})$", stripped):
+            para(buf); buf = []
+            out.append("<hr>")
+            i += 1
+            continue
+
+        if stripped.startswith(">"):
+            para(buf); buf = []
+            quote = []
+            while i < len(lines) and lines[i].strip().startswith(">"):
+                quote.append(lines[i].strip()[1:].strip())
+                i += 1
+            out.append(f"<blockquote>{to_html(chr(10).join(quote), image=image)}</blockquote>")
+            continue
+
+        if re.match(r"^([-*+]|\d+[.)])\s+", stripped):
+            para(buf); buf = []
+            ordered = bool(re.match(r"^\d", stripped))
+            items = []
+            while i < len(lines) and re.match(r"^\s*([-*+]|\d+[.)])\s+", lines[i]):
+                items.append(re.sub(r"^\s*([-*+]|\d+[.)])\s+", "", lines[i]))
+                i += 1
+            tag = "ol" if ordered else "ul"
+            out.append(f"<{tag}>" + "".join(f"<li>{_inline(it, image)}</li>" for it in items)
+                       + f"</{tag}>")
+            continue
+
+        if stripped.startswith("|") and i + 1 < len(lines) \
+                and re.match(r"^\|?\s*:?-{3,}", lines[i + 1].strip()):
+            para(buf); buf = []
+
+            def cells(row):
+                return [c.strip() for c in row.strip().strip("|").split("|")]
+
+            head = cells(lines[i])
+            i += 2
+            rows = []
+            while i < len(lines) and lines[i].strip().startswith("|"):
+                rows.append(cells(lines[i]))
+                i += 1
+            html = "<table><tr>" + "".join(f"<th>{_inline(h, image)}</th>" for h in head) + "</tr>"
+            for r in rows:
+                html += "<tr>" + "".join(f"<td>{_inline(c, image)}</td>" for c in r) + "</tr>"
+            out.append(html + "</table>")
+            continue
+
+        buf.append(line)
+        i += 1
+
+    para(buf)
+    return "\n".join(out)
diff --git a/soleprint/atlas2/docgen/emitters/notebook.py b/soleprint/atlas2/docgen/emitters/notebook.py
index 32df47f..964a9e4 100644
--- a/soleprint/atlas2/docgen/emitters/notebook.py
+++ b/soleprint/atlas2/docgen/emitters/notebook.py
@@ -40,7 +40,7 @@ METADATA = {
 }
 
 
-def _cell(index: int, kind: str, text: str) -> dict:
+def _cell(index: int, kind: str, text: str, attachments: dict | None = None) -> dict:
     lines = text.split("\n")
     source = [ln + "\n" for ln in lines[:-1]] + ([lines[-1]] if lines[-1] else [])
     cell = {
@@ -49,6 +49,12 @@ def _cell(index: int, kind: str, text: str) -> dict:
         "metadata": {},
         "source": source,
     }
+    if attachments and kind == "md":
+        # nbformat 4 lets a markdown cell carry its own images, referenced as
+        # `attachment:<name>`. That is how a figure renders without the notebook
+        # being run: nothing is an output, so "run all" cannot clear it, and the
+        # same SVG gives the same bytes every build.
+        cell["attachments"] = {name: dict(bundle) for name, bundle in sorted(attachments.items())}
     if kind == "code":
         cell["execution_count"] = None
         cell["outputs"] = []
@@ -212,15 +218,50 @@ def _call_md(step: dict) -> str:
     return "\n".join(out)
 
 
+def _figure_md(step: dict) -> str:
+    """A page of a paginated diagram, as markdown.
+
+    The anchor is an explicit `<a name>` rather than the heading's own: JupyterLab
+    and VS Code derive heading anchors differently, and JupyterLab's sanitiser
+    keeps `name` where it drops `id`. The page index links to these.
+    """
+    parts = []
+    if step.get("anchor"):
+        parts.append(f'<a name="{step["anchor"]}"></a>')
+        parts.append("")
+    if step.get("title"):
+        parts.append(f'{"#" * min(6, 2 + int(step.get("depth", 0)))} {step["title"]}')
+        parts.append("")
+    if step.get("svg"):
+        parts.append(f'![{step.get("title", "figure")}](attachment:{step["name"]})')
+    else:
+        parts.append(f'*Not drawn here — {step.get("why", "no renderer")}.*')
+    if step.get("caption"):
+        parts += ["", f'*{step["caption"]}*']
+    return "\n".join(parts)
+
+
+def _figure_attachments(step: dict) -> dict | None:
+    if not step.get("svg"):
+        return None
+    import base64
+
+    data = step["svg"].encode("utf-8") if isinstance(step["svg"], str) else step["svg"]
+    return {step["name"]: {"image/svg+xml": base64.b64encode(data).decode("ascii")}}
+
+
 def build(spec: dict) -> dict:
     """A merged notebook spec -> the notebook, as a dict."""
-    blocks: list[tuple[str, str]] = []
+    blocks: list[tuple] = []
 
     for step in spec["steps"]:
         kind = step.get("kind", "md")
         before = step.get("before")
         if before:
-            blocks.append(("md", before))
+            blocks.append(("md", before, step.get("before_attachments")))
+
+        if kind == "figure":
+            blocks.append(("md", _figure_md(step), _figure_attachments(step)))
 
         if kind == "md":
             text = []
@@ -259,7 +300,7 @@ def build(spec: dict) -> dict:
             blocks.append(("md", after))
 
     return {
-        "cells": [_cell(i, k, t) for i, (k, t) in enumerate(blocks)],
+        "cells": [_cell(i, *block) for i, block in enumerate(blocks)],
         "metadata": METADATA,
         "nbformat": 4,
         "nbformat_minor": 5,
diff --git a/soleprint/atlas2/docgen/emitters/paged.py b/soleprint/atlas2/docgen/emitters/paged.py
new file mode 100644
index 0000000..92ba6f1
--- /dev/null
+++ b/soleprint/atlas2/docgen/emitters/paged.py
@@ -0,0 +1,118 @@
+"""
+Draw pages: measure each one against a width, then render it for an output.
+
+`ops/pages.py` decides which pages exist and never renders anything — `ops/`
+imports no emitter. This is the other half: the `fits` test it needs, and the
+drawing of a laid-out page, with the links an output wants.
+
+## Measured, not estimated
+
+A layered drawing's width is its widest level, but *how* wide depends on the
+labels, the font and the spacing the style sets. A count-based estimate was off
+by enough to matter, so when Graphviz is present a page is rendered and its
+`width="Npt"` read back. Without Graphviz the estimate is all there is, and the
+page records `measured: False` so nobody mistakes one for the other.
+
+## Points and pixels
+
+Graphviz and the ERD emitter both write sizes in points, and a browser draws a
+point as 4/3 of a CSS pixel. Budgets here are pixels, because the column they
+have to fit — a notebook cell, a site's content column — is sized in pixels.
+"""
+
+import re
+
+PT_TO_PX = 4 / 3
+
+# Budgets for the outputs docgen writes. A notebook cell in JupyterLab or VS Code
+# is a little under a thousand pixels at a normal window size; the site's content
+# column is set by `site.CONTENT_W`.
+NOTEBOOK_WIDTH = 960
+
+
+def svg_width_px(svg: str) -> float | None:
+    m = re.search(r'<svg[^>]*\swidth="([\d.]+)(pt|px)?"', svg)
+    if not m:
+        return None
+    value = float(m.group(1))
+    return value * PT_TO_PX if (m.group(2) or "pt") == "pt" else value
+
+
+def _estimate_px(ir: dict, options: dict) -> float:
+    """Width without a renderer: widest level of boxes, or levels side by side."""
+    from ..ops import shape
+
+    sh = shape(ir)
+    labels = [len(n.get("label") or n["id"]) for n in ir["nodes"]] or [8]
+    box = 7 * (sum(labels) / len(labels)) + 40
+    if options.get("rankdir") == "LR":
+        return sh["levels"] * (box + 58) + 30
+    return sh["widest_level"] * (box + 36) + 30
+
+
+def fits_for(style, width: int):
+    """A `fits(page_ir, options) -> bool` for `ops.pages.layout`, at `width` px.
+
+    Also returns whether it measured or estimated, so the ledger can say which.
+    """
+    from .dot import emit, have_graphviz, render
+
+    measured = have_graphviz()
+
+    def fits(ir: dict, options: dict) -> bool:
+        if not measured:
+            return _estimate_px(ir, options) <= width
+        svg = render(emit(ir, style, rankdir=options.get("rankdir"))).decode("utf-8")
+        px = svg_width_px(svg)
+        return px is not None and px <= width
+
+    return fits, measured
+
+
+def links_for(pages: list[dict], page: dict, url) -> dict:
+    """{box id on this page: url of the page that box opens}.
+
+    `url(target_page)` builds the address, so the site and anything else that
+    can follow a link decide their own scheme. Context boxes link too, when their
+    branch has a page of its own — that is how a reader crosses to a sibling.
+    """
+    by_scope = {p.get("scope") or p["id"]: p for p in pages}
+    by_id = {p["id"]: p for p in pages}
+    out = {}
+    for n in page["ir"]["nodes"]:
+        target = by_id.get(n["id"]) if page.get("tables") else by_scope.get(n["id"])
+        if target is not None and target is not page:
+            out[n["id"]] = url(target)
+    return out
+
+
+def render(page: dict, style, width: int, *, links: dict | None = None) -> str | None:
+    """A laid-out page as SVG text, or None when it cannot be drawn here.
+
+    Schema pages go through the ERD emitter with its columns capped to `width`;
+    everything else, schema overviews included, through Graphviz with the page's
+    layout options and the caller's links.
+    """
+    if page.get("tables") and page["id"] != "overview":
+        from .erd import emit as erd
+
+        return erd(page["ir"], style, width=width)
+
+    from .dot import emit, have_graphviz, render as dot_render
+
+    if not have_graphviz():
+        return None
+    svg = dot_render(emit(page["ir"], style, rankdir=(page.get("options") or {}).get("rankdir"),
+                          links=links)).decode("utf-8")
+    return svg
+
+
+def inline(svg: str) -> str:
+    """SVG text ready to sit inside HTML: no XML declaration, no DOCTYPE.
+
+    Inline rather than `<img>`, because an image swallows every click and the
+    whole point of a page's boxes is that they open other pages.
+    """
+    svg = re.sub(r"<\?xml[^>]*\?>\s*", "", svg)
+    svg = re.sub(r"<!DOCTYPE[^>]*>\s*", "", svg)
+    return re.sub(r"<!--.*?-->\s*", "", svg, flags=re.S).strip()
diff --git a/soleprint/atlas2/docgen/emitters/site.py b/soleprint/atlas2/docgen/emitters/site.py
index 7057d9c..e48c933 100644
--- a/soleprint/atlas2/docgen/emitters/site.py
+++ b/soleprint/atlas2/docgen/emitters/site.py
@@ -177,6 +177,11 @@ CSS = """/* Generated by docgen. The layout five demos converged on: a sticky si
   --muted: __MUTED__;
   --dim: __DIM__;
   --accent: __ACCENT__;
+  /* Used by the ledger's "incomplete" panel. Declared here because it was not,
+     and an undefined custom property falls back silently — the warning rendered
+     in the ordinary text colour, which is the one place it must not. */
+  --artery: __ARTERY__;
+  --ok: __OK__;
 }
 * { margin: 0; padding: 0; box-sizing: border-box; }
 body {
@@ -267,6 +272,44 @@ body {
 .gap b { color: var(--artery); }
 .gap ul { margin: .4rem 0 0 1.1rem; color: var(--muted); }
 .gap code { font-size: 11px; }
+
+/* -- pages ------------------------------------------------------------------
+   A page is one subsystem drawn small enough to read. The diagram is inline SVG,
+   not an <img>, so its boxes are links: a group opens its own page, a module
+   opens its section of the reference page. */
+.crumbs { color: var(--dim); font-size: 11px; margin-bottom: .6rem; }
+.crumbs a { color: var(--muted); text-decoration: none; }
+.crumbs a:hover { color: var(--accent); }
+.note { margin: 0 0 1.2rem; }
+.note h1, .note h2, .note h3 { color: var(--text); margin: 1rem 0 .4rem; font-size: 14px; }
+.note p, .note li { color: var(--muted); margin-bottom: .5rem; }
+.note ul, .note ol { margin: 0 0 .8rem 1.2rem; }
+.note pre { background: var(--surface); border: 1px solid var(--border); border-radius: 6px;
+            padding: .6rem .8rem; overflow-x: auto; margin: .6rem 0; }
+.note code { font-size: 11px; }
+.note table { border-collapse: collapse; margin: .6rem 0; }
+.note th, .note td { border-bottom: 1px solid var(--border); padding: 4px 12px 4px 0; text-align: left; }
+.note blockquote { border-left: 2px solid var(--border); padding-left: .8rem; color: var(--dim); }
+.note img { max-width: 100%; }
+.figbar { display: flex; gap: 6px; align-items: center; margin-bottom: .4rem; font-size: 11px; color: var(--dim); }
+.figbar button, .figbar a {
+  background: var(--surface); color: var(--muted); border: 1px solid var(--border);
+  border-radius: 5px; padding: 2px 8px; font-size: 11px; cursor: pointer; text-decoration: none; }
+.figbar button.on { color: var(--accent); border-color: var(--accent); }
+.fig { border: 1px solid var(--border); border-radius: 8px; background: var(--surface);
+       padding: 8px; overflow: hidden; }
+.fig svg { display: block; max-width: 100%; height: auto; margin: 0 auto; }
+.fig.actual { overflow: auto; }
+.fig.actual svg { max-width: none; }
+.fig a:hover polygon, .fig a:hover path { stroke: var(--accent); }
+.caption { color: var(--dim); font-size: 11px; margin: .4rem 0 1.2rem; }
+.caption.warn { color: var(--artery); }
+.children { columns: 2; margin: .4rem 0 1.4rem; list-style: none; }
+.children li { margin-bottom: 2px; }
+.books { display: grid; gap: 1rem; margin: 1rem 0 2rem; }
+.bookcard { border: 1px solid var(--border); border-radius: 8px; padding: .9rem 1rem; }
+.bookcard h2 { font-size: 15px; margin-bottom: .5rem; }
+.bookcard .links a { margin-right: 1rem; font-size: 12px; }
 """
 
 
@@ -337,6 +380,8 @@ def _slots(style) -> dict:
         "__MUTED__": s("text-muted"),
         "__DIM__": s("text-dim"),
         "__ACCENT__": s("accent"),
+        "__ARTERY__": s("error") or s("artery"),
+        "__OK__": s("ok") or s("atlas"),
         "__FONT__": '"Segoe UI", Inter, system-ui, -apple-system, Arial, sans-serif',
     }
 
diff --git a/soleprint/atlas2/docgen/fixtures/notes/_intro.md b/soleprint/atlas2/docgen/fixtures/notes/_intro.md
new file mode 100644
index 0000000..b92345c
--- /dev/null
+++ b/soleprint/atlas2/docgen/fixtures/notes/_intro.md
@@ -0,0 +1,3 @@
+<!-- docgen note: top of the document. Write markdown below; this comment does not render, and an empty note adds nothing. -->
+The fixtures docgen tests itself against: a Python tree, a schema and an API
+contract, built into one document to show the parts fitting together.
diff --git a/soleprint/atlas2/docgen/fixtures/notes/schema/overview.md b/soleprint/atlas2/docgen/fixtures/notes/schema/overview.md
new file mode 100644
index 0000000..bd8e658
--- /dev/null
+++ b/soleprint/atlas2/docgen/fixtures/notes/schema/overview.md
@@ -0,0 +1,5 @@
+<!-- docgen note: schema › page Overview. Write markdown below; this comment does not render, and an empty note adds nothing. -->
+## Where to start
+
+`orders` is the centre: every line belongs to one, and every order to one user.
+Open the page to see the keys.
diff --git a/soleprint/atlas2/docgen/notebook/spec.py b/soleprint/atlas2/docgen/notebook/spec.py
index cb8c7e6..76b5116 100644
--- a/soleprint/atlas2/docgen/notebook/spec.py
+++ b/soleprint/atlas2/docgen/notebook/spec.py
@@ -51,7 +51,7 @@ from pathlib import Path
 SPEC_VERSION = "1"
 
 # Step kinds. Small and closed, the same discipline the IR's `kind` follows.
-KINDS = ("md", "code", "params", "call")
+KINDS = ("md", "code", "params", "call", "figure")
 
 
 def _step(id: str, kind: str, **fields) -> dict:
diff --git a/soleprint/atlas2/docgen/ops/pages.py b/soleprint/atlas2/docgen/ops/pages.py
new file mode 100644
index 0000000..22dc851
--- /dev/null
+++ b/soleprint/atlas2/docgen/ops/pages.py
@@ -0,0 +1,382 @@
+"""
+Pages: a graph too big for one picture, as a set of pictures that each fit.
+
+    pages = paginate(view)                # the structure: which pages exist
+    laid = layout(pages, fits)            # per output: fits(page_ir, options) -> bool
+
+A notebook scales an image down to its cell width, so a wide graph does not
+scroll — it shrinks until its labels are unreadable. The only fix that holds is
+to draw less per picture. This decides *what* goes on each picture; the caller
+decides whether it fits, by rendering it and measuring, because a width
+estimated from node counts is wrong the moment the labels are long.
+
+**Which pages exist does not depend on width** — only how each one is laid out
+does. So the two are separate calls: the page ids a note is filed under are the
+same for a notebook column and a site column, and listing them needs no
+renderer at all.
+
+## By structure, never by slicing
+
+Tiling one large image cuts boxes and edges at the seams, and a tile means
+nothing on its own. A page here is a subsystem:
+
+    overview                 one box per top-level group, relationships lifted
+    └── station              one box per child of `station`
+        └── station.tools    one box per child of `station.tools`, and so on
+
+Clicking a box — on the site — or following the index — in a notebook — moves
+down a level. Every page is a real graph: the boxes are the scope's children,
+and anything outside the scope that they touch appears as a **context** box,
+collapsed to the branch it sits on, so a page still says what its subsystem
+reaches without drawing the rest of the tree.
+
+## Groups come from the id, not from `parent`
+
+A directory without `__init__.py` is not a Python package, so its modules have
+no `parent` — soleprint has 173 such roots — but their dotted ids still carry
+the directory. `split()` groups on id segments for the same reason. A group with
+no node of its own (such a directory) is synthesised on the page as a box of
+the kind most of its contents are, marked `attrs.group`.
+
+## When a level cannot be narrowed
+
+A scope whose children genuinely are many peers has no smaller structure to
+split into. It is redrawn left-to-right — height is free in a notebook, width is
+not — and if that still does not fit, the page is kept and flagged `too_wide`.
+Never cut, never dropped: a flagged page is honest, a missing one is not.
+
+## Schemas page differently
+
+A schema is peers with references, drawn as cards in columns whose count the
+emitter caps to the width, so width is never the problem — count is. Tables are
+paged by connected component (tables joined by foreign keys stay together), and
+tables with no keys at all are chunked alphabetically.
+"""
+
+import re
+
+OVERVIEW = "overview"
+MAX_TABLES = 20                 # past this a schema page stops being scannable
+
+
+def slugify(page_id: str) -> str:
+    """A filename- and anchor-safe name for a page id.
+
+    Ids are not safe as they stand: an endpoint id is `GET /orders/{id}`, and a
+    tree-sitter id can carry `#L12`.
+    """
+    slug = re.sub(r"[^A-Za-z0-9._-]+", "-", page_id).strip("-.")
+    return slug or "page"
+
+
+def _key(node_id: str, scope: str) -> str:
+    """The box at `scope` that `node_id` falls into: scope + one more segment."""
+    if scope == "":
+        return node_id.split(".", 1)[0]
+    if node_id == scope:
+        return scope
+    rest = node_id[len(scope) + 1:]
+    return f"{scope}.{rest.split('.', 1)[0]}"
+
+
+def _under(node: dict, scope: str) -> bool:
+    if node["kind"] == "external":
+        return False            # externals are context everywhere, never members
+    nid = node["id"]
+    return scope == "" or nid == scope or nid.startswith(scope + ".")
+
+
+def _representative(node_id: str, scope: str) -> str:
+    """Where an outside node shows on this page: the branch it diverges on.
+
+    The common prefix of the scope and the node, plus one more segment of the
+    node's id. That box is never an ancestor of the scope (it is on the node's
+    branch, past the point they part), so it never swallows the page's own
+    members — and two outside nodes on the same branch share one box.
+    """
+    s, n = scope.split(".") if scope else [], node_id.split(".")
+    common = 0
+    while common < len(s) and common < len(n) and s[common] == n[common]:
+        common += 1
+    return ".".join(n[: common + 1])
+
+
+def page_ir(view: dict, scope: str) -> tuple[dict, dict]:
+    """The graph for one page, and {member key: [node ids it stands for]}.
+
+    Built directly rather than through `_rebuild`, because a synthesised group
+    box and a context box have no node in the source graph to keep.
+    """
+    by_id = {n["id"]: n for n in view["nodes"]}
+    members: dict[str, list] = {}
+    for n in view["nodes"]:
+        if _under(n, scope):
+            members.setdefault(_key(n["id"], scope), []).append(n["id"])
+
+    where = {nid: key for key, ids in members.items() for nid in ids}
+    context: dict[str, list] = {}
+    for e in view["edges"]:
+        s_in, t_in = e["source"] in where, e["target"] in where
+        if s_in == t_in:
+            continue            # internal to the page (handled below) or unrelated
+        outside = e["target"] if s_in else e["source"]
+        rep = _representative(outside, scope)
+        if rep in members:
+            continue            # cannot happen for a well-formed tree; stay safe
+        context.setdefault(rep, []).append(outside)
+        where.setdefault(outside, rep)
+
+    nodes = []
+    for key, ids in sorted(members.items()) + sorted(context.items()):
+        is_context = key in context and key not in members
+        own = by_id.get(key)
+        ids = sorted(set(ids))
+        if own is not None and (ids == [key] or not is_context):
+            node = {"id": key, "kind": own["kind"], "label": own.get("label") or key,
+                    "parent": None, "attrs": dict(own.get("attrs") or {})}
+        else:
+            kinds = [by_id[i]["kind"] for i in ids if i in by_id]
+            kind = max(set(kinds), key=lambda k: (kinds.count(k), k)) if kinds else "module"
+            node = {"id": key, "kind": kind, "label": key.rsplit(".", 1)[-1],
+                    "parent": None, "attrs": {}}
+        # Semantic, not visual: which boxes are subsystems to open, and which are
+        # the outside world seen from here. How that looks is style's decision.
+        grouped = [i for i in ids if i != key]
+        if grouped or (own is None):
+            node["attrs"]["group"] = True
+            node["attrs"]["count"] = len(ids)
+        if is_context:
+            node["attrs"]["context"] = True
+        nodes.append(node)
+
+    merged: dict[tuple, dict] = {}
+    for e in view["edges"]:
+        src, dst = where.get(e["source"]), where.get(e["target"])
+        if src is None or dst is None or src == dst:
+            continue
+        if src in context and dst in context:
+            continue            # two outside boxes: not this page's relationship
+        k = (src, dst, e["kind"])
+        if k in merged:
+            merged[k]["attrs"]["weight"] = merged[k]["attrs"].get("weight", 1) + 1
+            continue
+        attrs = dict(e.get("attrs") or {})
+        if src != e["source"] or dst != e["target"]:
+            attrs = {"weight": 1}
+        merged[k] = {"source": src, "target": dst, "kind": e["kind"], "attrs": attrs}
+
+    ir = {"meta": dict(view["meta"]), "nodes": nodes,
+          "edges": sorted(merged.values(), key=lambda e: (e["source"], e["target"], e["kind"]))}
+    return ir, members
+
+
+def layout(pages: list[dict], fits) -> list[dict]:
+    """The same pages, each with the layout that fits: top-to-bottom, then
+    left-to-right, then flagged `too_wide`. Returns new page dicts.
+
+    Schema pages are left alone — the ERD emitter caps its own columns to the
+    width, so they always fit — except the overview, which is a graph.
+    """
+    out = []
+    for page in pages:
+        page = dict(page)
+        if page.get("tables") and page["id"] != OVERVIEW:
+            page["options"], page["too_wide"] = {}, False
+        elif fits(page["ir"], {}):
+            page["options"], page["too_wide"] = {}, False
+        elif fits(page["ir"], {"rankdir": "LR"}):
+            page["options"], page["too_wide"] = {"rankdir": "LR"}, False
+        else:
+            page["options"], page["too_wide"] = {"rankdir": "LR"}, True
+        out.append(page)
+    return out
+
+
+def paginate(view: dict, *, max_depth: int = 6) -> list[dict]:
+    """Pages for a graph, overview first, each drawn as a subsystem.
+
+    Returns a list of::
+
+        {"id", "slug", "title", "scope", "parent", "depth", "ir",
+         "children": [page ids], "options": {}, "too_wide": False}
+
+    `options` and `too_wide` are placeholders until `layout()` fills them.
+
+    in reading order — a page is followed by its own children, depth first — so
+    a notebook can emit them in sequence and a site can build its tree from
+    `parent` and `children`.
+    """
+    pages: list[dict] = []
+    slugs: set[str] = set()
+
+    def unique(slug: str) -> str:
+        base, i = slug, 2
+        while slug in slugs:
+            slug, i = f"{base}-{i}", i + 1
+        slugs.add(slug)
+        return slug
+
+    def opens(key: str, scope: str, ids: list) -> bool:
+        # A box opens into a page when it stands for more than itself.
+        return key != scope and any(i != key for i in ids)
+
+    def visit(scope: str, parent: str | None, depth: int, page_id: str | None = None):
+        ir, members = page_ir(view, scope)
+        if not ir["nodes"]:
+            return
+        # A page whose only member is one group says nothing but "open this" —
+        # docgen's own overview was one box reading `docgen`. Descend instead,
+        # keeping the id the caller expects, so the overview is still `overview`.
+        groups = [k for k, ids in members.items() if opens(k, scope, ids)]
+        if len(members) == 1 and len(groups) == 1:
+            return visit(groups[0], parent, depth, page_id or (scope or OVERVIEW))
+        page_id = page_id or scope or OVERVIEW
+        page = {
+            "id": page_id,
+            "slug": unique(slugify(page_id)),
+            "title": scope if scope and page_id == scope else (scope or "Overview"),
+            "scope": scope,
+            "parent": parent,
+            "depth": depth,
+            "ir": ir,
+            "options": {},
+            "children": [],
+            "too_wide": False,
+        }
+        pages.append(page)
+        if depth >= max_depth:
+            return
+        for key in sorted(members):
+            if opens(key, scope, members[key]):
+                page["children"].append(key)
+                visit(key, page_id, depth + 1)
+
+    visit("", None, 0)
+    return pages
+
+
+def paginate_tables(view: dict, *, max_tables: int = MAX_TABLES) -> list[dict]:
+    """Pages for a schema: connected components, packed, then chunked.
+
+    Each page is the tables plus their columns, so the ERD emitter draws cards.
+    The overview has one box per page, which is what a reader opens from.
+    """
+    tables = sorted(n["id"] for n in view["nodes"] if n["kind"] == "table")
+    links: dict[str, set] = {t: set() for t in tables}
+    for e in view["edges"]:
+        if e["source"] in links and e["target"] in links:
+            links[e["source"]].add(e["target"])
+            links[e["target"]].add(e["source"])
+
+    seen, components = set(), []
+    for t in tables:
+        if t in seen:
+            continue
+        stack, comp = [t], []
+        while stack:
+            cur = stack.pop()
+            if cur in seen:
+                continue
+            seen.add(cur)
+            comp.append(cur)
+            stack.extend(links[cur] - seen)
+        components.append(sorted(comp))
+
+    connected = sorted((c for c in components if len(c) > 1), key=lambda c: (-len(c), c[0]))
+    lonely = sorted(c[0] for c in components if len(c) == 1)
+
+    groups: list[list[str]] = []
+    for comp in connected:
+        # A component larger than a page is still split — by name, since a
+        # foreign-key cluster has no finer structure to split on — and the cut
+        # keys show as edges to the other page's tables in neither, which the
+        # overview's lifted edges make up for.
+        for i in range(0, len(comp), max_tables):
+            groups.append(comp[i:i + max_tables])
+    for i in range(0, len(lonely), max_tables):
+        groups.append(lonely[i:i + max_tables])
+
+    by_id = {n["id"]: n for n in view["nodes"]}
+    pages: list[dict] = []
+    table_page: dict[str, str] = {}
+    for i, group in enumerate(groups, start=1):
+        pid = group[0] if len(group) == 1 else f"{group[0]}…{group[-1]}"
+        slug = f"tables-{i:02d}"
+        for t in group:
+            table_page[t] = slug
+        keep = set(group) | {n["id"] for n in view["nodes"] if n.get("parent") in set(group)}
+        ir = {"meta": dict(view["meta"]),
+              "nodes": [dict(by_id[n]) for n in sorted(keep)],
+              "edges": [dict(e) for e in view["edges"]
+                        if e["source"] in keep and e["target"] in keep]}
+        pages.append({"id": slug, "slug": slug, "title": pid, "scope": slug,
+                      "parent": OVERVIEW, "depth": 1, "ir": ir, "options": {},
+                      "children": [], "too_wide": False, "tables": True})
+
+    over_nodes = [{"id": p["id"], "kind": "table", "label": p["title"], "parent": None,
+                   "attrs": {"group": True, "count": sum(
+                       1 for n in p["ir"]["nodes"] if n["kind"] == "table")}}
+                  for p in pages]
+    merged: dict[tuple, dict] = {}
+    for e in view["edges"]:
+        a, b = table_page.get(e["source"]), table_page.get(e["target"])
+        if a and b and a != b:
+            k = (a, b, e["kind"])
+            merged.setdefault(k, {"source": a, "target": b, "kind": e["kind"],
+                                  "attrs": {"weight": 0}})
+            merged[k]["attrs"]["weight"] += 1
+    overview = {"id": OVERVIEW, "slug": OVERVIEW, "title": "Overview", "scope": "",
+                "tables": True, "parent": None,
+                "depth": 0, "ir": {"meta": dict(view["meta"]), "nodes": over_nodes,
+                                   "edges": list(merged.values())},
+                "options": {}, "children": [p["id"] for p in pages], "too_wide": False}
+    return [overview] + pages
+
+
+def coverage(view: dict, pages: list[dict]) -> list[str]:
+    """Node ids of the view that no page accounts for. Empty means nothing lost.
+
+    A node is accounted for when a page shows it — as itself, or inside a box
+    that opens onto a page that does. Externals count when their branch appears
+    as context somewhere.
+    """
+    shown = set()
+    for p in pages:
+        shown |= {n["id"] for n in p["ir"]["nodes"]}
+    # Schema pages draw tables and their columns; an API's endpoints are the
+    # notebook's walkthrough, not a diagram, so they are not a page's to account for.
+    tables_only = bool(pages) and pages[0].get("tables")
+    missing = []
+    for n in view["nodes"]:
+        if tables_only and n["kind"] not in ("table", "column"):
+            continue
+        nid = n["id"]
+        if nid in shown:
+            continue
+        parts = nid.split(".")
+        if n["kind"] == "external" and any(".".join(parts[:i]) in shown
+                                           for i in range(1, len(parts) + 1)):
+            continue
+        if n.get("parent") in shown and n["kind"] == "column":
+            continue
+        missing.append(nid)
+    return sorted(missing)
+
+
+def for_view(ir: dict, view: dict, *, max_depth: int = 6) -> list[dict]:
+    """The pages a book gets, whatever its source.
+
+    A schema pages by table — from the full IR, since a card needs its columns and
+    the default view drops them — and anything else pages by structure from the
+    view. The same decision `classify` makes about which emitter draws it.
+    """
+    from .filter import classify
+
+    if classify(view)["emitter"] == "erd":
+        tables = {"meta": ir["meta"],
+                  "nodes": [n for n in ir["nodes"] if n["kind"] in ("table", "column")],
+                  "edges": [e for e in ir["edges"]
+                            if e["kind"] in ("foreign_key", "references")]}
+        if any(n["kind"] == "table" for n in tables["nodes"]):
+            return paginate_tables(tables)
+    return paginate(view, max_depth=max_depth)
diff --git a/soleprint/atlas2/docgen/selftest.py b/soleprint/atlas2/docgen/selftest.py
index 4d3ab2e..9575d56 100644
--- a/soleprint/atlas2/docgen/selftest.py
+++ b/soleprint/atlas2/docgen/selftest.py
@@ -2319,6 +2319,453 @@ def _runfiles():
 _runfiles()
 
 
+
+# --------------------------------------------------------------------------
+print("\n19. pages — a graph too big for one picture, as pictures that each fit")
+
+
+def _pages():
+    pages_mod = __import__(f"{PKG}.ops.pages", fromlist=["*"])
+    paged = __import__(f"{PKG}.emitters.paged", fromlist=["*"])
+    dot = __import__(f"{PKG}.emitters.dot", fromlist=["*"])
+    from_ops = __import__(f"{PKG}.ops", fromlist=["*"])
+
+    # ops/ decides what goes on a page and must never draw one. Paging is exactly
+    # where the temptation lives — measuring a width wants a renderer — so the
+    # measure is passed in as `fits`, and this holds the line.
+    reaching = []
+    for path in sorted((HERE / "ops").glob("*.py")):
+        for node in ast.walk(ast.parse(path.read_text())):
+            if isinstance(node, ast.ImportFrom) and node.module and node.level \
+                    and node.module.split(".")[0] in ("emitters", "book", "cli", "extractors"):
+                reaching.append(f"{path.name}: {node.module}")
+    check("ops/ imports no emitter, book, command line or extractor", not reaching, reaching)
+
+    view = from_ops.overview(py_ex.extract(HERE).to_dict())
+    structure = pages_mod.paginate(view)
+
+    check(
+        "the first page is the overview",
+        structure[0]["id"] == pages_mod.OVERVIEW,
+        f"got {structure[0]['id']}",
+    )
+    check(
+        "every page is a valid IR on its own",
+        not [p["id"] for p in structure if check_ir(p["ir"])],
+    )
+    # The claim pagination is allowed to make: drawn smaller, never drawn less.
+    lost = pages_mod.coverage(view, structure)
+    check("pagination loses no node — each is on a page or inside a box that opens one",
+          not lost, f"{lost[:5]}")
+    ids = {p["id"] for p in structure}
+    check(
+        "every box that opens a page opens one that exists",
+        not [c for p in structure for c in p["children"] if c not in ids],
+    )
+    check(
+        "slugs are unique and safe as file names",
+        len({p["slug"] for p in structure}) == len(structure)
+        and all(re.fullmatch(r"[A-Za-z0-9._-]+", p["slug"]) for p in structure),
+    )
+    check(
+        "an endpoint id becomes a safe slug",
+        pages_mod.slugify("GET /orders/{orderId}") == "GET-orders-orderId",
+        pages_mod.slugify("GET /orders/{orderId}"),
+    )
+    # docgen's own overview used to be a single box reading `docgen`: a page
+    # whose only content is "open this". A lone group is descended into instead.
+    check(
+        "a page is never just one box that opens another page",
+        not [p["id"] for p in structure
+             if len([n for n in p["ir"]["nodes"] if not (n.get("attrs") or {}).get("context")]) == 1
+             and p["children"]],
+    )
+    # Which pages exist must not depend on width — notes are filed by page id,
+    # and a note has to land in the same place in a notebook and on a site.
+    check(
+        "which pages exist does not depend on width",
+        [p["id"] for p in pages_mod.layout(structure, lambda ir, o: False)]
+        == [p["id"] for p in pages_mod.layout(structure, lambda ir, o: True)],
+    )
+    narrow = pages_mod.layout(structure, lambda ir, o: False)
+    check(
+        "a page that fits no way is kept and flagged, never dropped",
+        len(narrow) == len(structure) and all(p["too_wide"] for p in narrow),
+    )
+
+    # -- measured against a real width --------------------------------------
+    if not dot.have_graphviz():
+        skip("pages fit their width", "Graphviz is not installed")
+    else:
+        lucid_style = Style.load("lucid")
+        fits, measured = paged.fits_for(lucid_style, 800)
+        laid = pages_mod.layout(structure, fits)
+        over = []
+        for p in laid:
+            px = paged.svg_width_px(paged.render(p, lucid_style, 800))
+            if px > 800 and not p["too_wide"]:
+                over.append(f"{p['id']} {px:.0f}px")
+        check("no page is wider than its budget unless it says so", not over, "; ".join(over))
+        # Links are the output's, never the IR's: a site passes them, and then a
+        # relative source path — a dead link on a web page — must not survive.
+        page = next(p for p in laid if p["children"])
+        links = paged.links_for(laid, page, lambda t: f"{t['slug']}.html")
+        svg = paged.render(page, lucid_style, 800, links=links)
+        check(
+            "a box that opens a page links to it",
+            all(f'href="{url}"' in svg for url in links.values()) and links,
+            f"{len(links)} links",
+        )
+        check(
+            "an output that manages links drops the source-file hrefs",
+            ".py" not in "".join(re.findall(r'href="([^"]+)"', svg)),
+        )
+
+    # Schemas page by table, and a card grows downward rather than sideways.
+    shop = db_ex.extract(HERE / "fixtures" / "shop.json").to_dict()
+    tables = pages_mod.for_view(shop, from_ops.overview(shop))
+    check(
+        "a schema pages by connected tables, cards with their columns",
+        tables[0]["id"] == "overview" and tables[1].get("tables")
+        and any(n["kind"] == "column" for n in tables[1]["ir"]["nodes"]),
+    )
+    many = {"models": {f"t{i:02d}": {"fields": {"id": {"type": "int", "pk": True}}}
+                       for i in range(12)}}
+    wide_ir = db_ex.from_schema_dict(many, root="x").to_dict()
+    svg = erd_mod.emit(wide_ir, lucid, width=800)
+    check(
+        "an ERD capped to a width stays inside it",
+        paged.svg_width_px(svg) <= 800,
+        f"{paged.svg_width_px(svg):.0f}px",
+    )
+
+
+_pages()
+
+
+# --------------------------------------------------------------------------
+print("\n20. notes, figures and pages — the hand-written part, and where it lands")
+
+
+def _documents():
+    doc_mod = __import__(f"{PKG}.book.document", fromlist=["*"])
+    notes_mod = __import__(f"{PKG}.book.notes", fromlist=["*"])
+    build_mod = __import__(f"{PKG}.book.build", fromlist=["*"])
+    checks_mod = __import__(f"{PKG}.book.checks", fromlist=["*"])
+    md = __import__(f"{PKG}.emitters.markdown", fromlist=["*"])
+    dot = __import__(f"{PKG}.emitters.dot", fromlist=["*"])
+    import io as _io3
+    import contextlib as _ctx3
+
+    base = Path(tmp.name) / "documents"
+    src = base / "src" / "shop"
+    for sub in ("orders", "billing"):
+        (src / sub).mkdir(parents=True, exist_ok=True)
+        (src / sub / "__init__.py").write_text(f'"""{sub}."""\n')
+        (src / sub / "models.py").write_text(f'"""{sub} models."""\nfrom shop.{sub} import x\n')
+    (src / "__init__.py").write_text('"""shop."""\n')
+    notes = base / "notes"
+
+    # -- notes ---------------------------------------------------------------
+    stubbed = notes_mod.Notes(notes).scaffold({"app": [("overview", "page Overview")]})
+    check("scaffold writes a stub per spot", (notes / "app" / "overview.md") in stubbed)
+    check("a stub renders nothing", notes_mod.body((notes / "app" / "overview.md").read_text()) is None)
+    (notes / "app" / "overview.md").write_text(
+        (notes / "app" / "overview.md").read_text() + "## Written by hand\n\nKept.\n")
+    again = notes_mod.Notes(notes).scaffold({"app": [("overview", "page Overview")]})
+    check(
+        "scaffold never overwrites a note",
+        (notes / "app" / "overview.md") not in again
+        and "Written by hand" in (notes / "app" / "overview.md").read_text(),
+    )
+    (notes / "img").mkdir(exist_ok=True)
+    (notes / "img" / "dot.svg").write_text('<svg xmlns="http://www.w3.org/2000/svg"/>')
+    (notes / "app" / "overview.md").write_text(
+        (notes / "app" / "overview.md").read_text() + "\n![a dot](../img/dot.svg)\n")
+    (notes / "app" / "no-such-page.md").write_text("Filed under a page that is gone.\n")
+
+    # A note is text: raw HTML is shown, not run, and a link cannot break out of
+    # its attribute or run script.
+    html = md.to_html('<script>x</script> [a](b"onclick=1) [c](javascript:alert(1))')
+    check(
+        "a note's HTML is escaped and its links are attribute-safe",
+        # The quote stays inside the attribute as &quot; — asserted on the exact
+        # attribute, since stripping the entity first (as this check once did)
+        # makes the attribute's own closing quote look like a break-out.
+        "<script>" not in html and 'href="b&quot;onclick=1"' in html
+        and not re.search(r'"\s*onclick=', html) and 'href="#"' in html,
+        html,
+    )
+
+    # -- a one-book document, built inline -------------------------------------
+    out = base / "book"
+    book = build_mod.run("python", src, out, slug="app", notes=notes, quiet=True)
+    ledger = json.loads((out / "document.json").read_text())
+    check(
+        "a note filed under a vanished page is reported, not dropped",
+        any("no-such-page" in d for d in ledger["notes"]["drift"]),
+        ledger["notes"]["drift"],
+    )
+    r = checks_mod.Report()
+    with _ctx3.redirect_stdout(_io3.StringIO()):
+        checks_mod.generated(checks_mod.Loaded(out), r)
+    check("...and fails the book's own checks", "no note is filed under a page or step that is gone" in r.failed)
+
+    nb = json.loads((out / "notebook.ipynb").read_text())
+    cells = ["".join(c["source"]) for c in nb["cells"]]
+    note_at = next(i for i, t in enumerate(cells) if "Written by hand" in t)
+    check(
+        "a note lands directly above its page",
+        '<a name="page-app-overview">' in cells[note_at + 1],
+        cells[note_at + 1][:60],
+    )
+    check(
+        "a note's local image travels with it, as an attachment",
+        "attachment:dot.svg" in cells[note_at] and nb["cells"][note_at].get("attachments"),
+    )
+    figures = [c for c in nb["cells"] if '<a name="page-' in "".join(c["source"])]
+    check(
+        "every page is a figure in the notebook",
+        len(figures) == len(book.pages), f"{len(figures)} figures, {len(book.pages)} pages",
+    )
+    if dot.have_graphviz():
+        check(
+            "a figure carries its SVG, so it renders without running anything",
+            all("image/svg+xml" in next(iter((c.get("attachments") or {"": {}}).values()))
+                for c in figures),
+        )
+    else:
+        skip("figures carry SVG", "Graphviz is not installed")
+    check("the page index links every page", all(
+        f"(#page-app-{p['slug']})" in "".join(cells) for p in book.pages))
+    ran, failure = checks_mod._run_cells(nb["cells"], out)
+    check(f"the notebook still runs ({ran} code cells)", failure is None, failure or "")
+
+    # Two builds, same bytes — attachments included.
+    first = (out / "notebook.ipynb").read_bytes()
+    build_mod.run("python", src, out, slug="app", notes=notes, quiet=True)
+    check("the same sources and notes build the same notebook", first == (out / "notebook.ipynb").read_bytes())
+
+    # -- the site: drill-down --------------------------------------------------
+    site = out / "site"
+    page_files = sorted((site / "app").glob("*.html"))
+    broken = []
+    for f in page_files:
+        for href in re.findall(r'href="([^"#?]+)', f.read_text()):
+            if not href.startswith(("http:", "https:")) and not (f.parent / href).exists():
+                broken.append(f"{f.name} -> {href}")
+    check("every link on every site page opens something", not broken, broken[:5])
+    overview_html = (site / "app" / "overview.html").read_text()
+    check(
+        "a page's diagram is inline, so its boxes can be clicked",
+        "<svg" in overview_html and "<?xml" not in overview_html and "<img" not in overview_html.split('class="fig"')[1][:200]
+        if dot.have_graphviz() else True,
+    )
+    child = next((p for p in book.pages if p["parent"]), None)
+    if child is not None:
+        child_html = (site / "app" / f"{child['slug']}.html").read_text()
+        check(
+            "a page links back up through its breadcrumbs",
+            'href="overview.html"' in child_html.split('class="crumbs"')[1].split("</div>")[0],
+        )
+    check("a page has a fit / 1:1 control", 'data-size="actual"' in overview_html)
+    check("the site renders the note above the diagram",
+          overview_html.index("Written by hand") < overview_html.index('class="figbar"'))
+
+    # Manifests: a rebuild removes what the last one wrote, and nothing else.
+    project_out = base / "project-site"
+    doc = doc_mod.Document(
+        name="p", title="P", build=base / "p-build", notes=None,
+        parts=[doc_mod.Part(name="app", kind="python", source=src, out=base / "p-build" / "app")],
+        outputs=[doc_mod.Output("site", project_out)])
+    doc_mod.build(doc)
+    (project_out / "app" / "stale.html").write_text("left by a previous build")
+    manifest = json.loads((project_out / ".docgen-output.json").read_text())
+    manifest["written"].append("app/stale.html")
+    (project_out / ".docgen-output.json").write_text(json.dumps(manifest))
+    (project_out / "hand-written.md").write_text("mine")
+    doc_mod.build(doc)
+    check("a rebuild removes a page the last build wrote and this one did not",
+          not (project_out / "app" / "stale.html").exists())
+    check("...and never a file it did not write", (project_out / "hand-written.md").exists())
+
+    # One book that cannot be built must not cost the document — and the document
+    # has to say it is short, where a reader will see it, not only in a terminal.
+    (base / "broken.har").write_text("not a recording")
+    partial_site = base / "partial-site"
+    partial = doc_mod.Document(
+        name="partial", title="Partial", build=base / "partial-build", notes=None,
+        parts=[doc_mod.Part(name="bad", kind="usage", source=base / "broken.har",
+                            out=base / "partial-build" / "bad"),
+               doc_mod.Part(name="app", kind="python", source=src,
+                            out=base / "partial-build" / "app")],
+        outputs=[doc_mod.Output("site", partial_site),
+                 doc_mod.Output("notebook", base / "partial.ipynb")])
+    doc_mod.build(partial)
+    check("a book that fails does not stop the others",
+          [b.slug for b in partial.books] == ["app"] and "bad" in partial.failed)
+    check("the site says the document is incomplete",
+          "This document is incomplete" in (partial_site / "index.html").read_text())
+    check("...and so does the notebook",
+          "This document is incomplete" in (base / "partial.ipynb").read_text())
+
+
+_documents()
+
+
+# --------------------------------------------------------------------------
+print("\n21. project files — one document, several sources, the shape a model writes")
+
+
+def _projects():
+    cfg = __import__(f"{PKG}.book.config", fromlist=["*"])
+
+    base = Path(tmp.name) / "projects"
+    (base / "src").mkdir(parents=True, exist_ok=True)
+    (base / "src" / "a.py").write_text('"""A."""\n')
+    (base / "shop.json").write_text((HERE / "fixtures" / "shop.json").read_text())
+
+    def load(text, name="docgen.toml"):
+        path = base / name
+        path.write_text(text)
+        try:
+            return cfg.load(path), []
+        except cfg.ConfigError as e:
+            return None, e.problems
+
+    project, problems = load(
+        '[project]\nname = "p"\n\n[extract.python]\nroot = "src"\n\n'
+        '[extract.db]\nschema = "shop.json"\n\n[ops]\ndrop_stdlib = true\n\n'
+        '[emit.notebook]\noutput = "out/nb"\n\n[emit.site]\noutput = "out/site"\nwidth = 700\n')
+    check("a project file loads", isinstance(project, cfg.ProjectFile), problems)
+    if project is None:
+        return
+    doc = project.document
+    check(
+        "each [extract.*] is a book, each [emit.*] an output of all of them",
+        [p.name for p in doc.parts] == ["python", "db"]
+        and sorted(o.emitter for o in doc.outputs) == ["notebook", "site"],
+    )
+    check("[ops] applies to every book", all(p.ops.get("drop_stdlib") for p in doc.parts))
+    check("an output's width is kept", next(o for o in doc.outputs if o.emitter == "site").width == 700)
+    books_file, _ = load('[[book]]\nname = "a"\nroot = "src"\n', "books.toml")
+    check("a [[book]] list still loads as it did", isinstance(books_file, cfg.RunFile))
+
+    _, both = load('[project]\nname = "p"\n[[book]]\nname = "a"\nroot = "src"\n', "both.toml")
+    check("a file with both shapes is refused", any("both [project] and [[book]]" in p for p in both), both)
+
+    # The keys a model reached for in a real dry run, each refused with what to
+    # do instead — and the database URL never repeated back, since it is a
+    # credential.
+    _, refused = load(
+        '[project]\nname = "p"\n\n'
+        '[extract.db]\nurl = "postgresql://user:hunter2@localhost:5432/app"\n\n'
+        '[extract.code]\nroot = "src"\next = [".sh", ".yaml", ".sql"]\n\n'
+        '[extract.seed]\nroot = "src"\n\n[emit.site]\noutput = "out"\n', "refused.toml")
+    text = "\n".join(refused)
+    check("a database url is refused, pointing at modelgen from-db",
+          "never connects" in text and "modelgen from-db" in text, refused)
+    check("...and the credential is not repeated in the error", "hunter2" not in text)
+    check("an extension with no grammar is refused, naming what exists",
+          "no grammar for .sh, .yaml, .sql" in text and ".cs" in text)
+    check("an unknown reader is refused, naming the readers", "no reader named 'seed'" in text)
+    _, inside = load('[project]\nname = "p"\n[extract.python]\nroot = "src"\n'
+                     '[emit.site]\noutput = "src/site"\n', "inside.toml")
+    check("an output inside a tree it reads is refused", any("inside the tree" in p for p in inside), inside)
+
+    example = cfg.load(HERE / "docgen.project.example.toml")
+    check("the shipped project example loads",
+          [p.name for p in example.document.parts] == ["extractors", "schema", "api"])
+
+
+_projects()
+
+
+
+# --------------------------------------------------------------------------
+print("\n22. the instructions for a model say what docgen accepts")
+
+
+def _contract():
+    """docs/models.md is what a model is told. It is only useful while true.
+
+    A model follows it literally: a key it names that the loader refuses is a
+    refused file, and a key the loader accepts that it never mentions is a
+    capability no model will use. So it is checked against the loaders
+    themselves, the way explode's contract is one copy printed by the script
+    that parses the reply.
+    """
+    cfg = __import__(f"{PKG}.book.config", fromlist=["*"])
+    code_ex = __import__(f"{PKG}.extractors.code", fromlist=["*"])
+    build_mod = __import__(f"{PKG}.book.build", fromlist=["*"])
+
+    doc_path = HERE / "docs" / "models.md"
+    check("docs/models.md exists", doc_path.is_file())
+    if not doc_path.is_file():
+        return
+    text = doc_path.read_text()
+
+    def named(word):
+        return f"`{word}`" in text or f'`"{word}"`' in text
+
+    keys = (cfg.TOP_KEYS | cfg.DEFAULT_KEYS | cfg.BOOK_KEYS | cfg.PROJECT_KEYS
+            | cfg.OPS_KEYS | cfg.EMIT_KEYS | set().union(*cfg.EXTRACT_KEYS.values()))
+    check("every key a loader accepts is named", not sorted(k for k in keys if not named(k)),
+          sorted(k for k in keys if not named(k)))
+    check("every reader is named", all(named(r) for r in cfg.EXTRACT_KEYS))
+    check("every output is named", all(named(e) for e in cfg.EMITTERS))
+    # Read off the one line that lists them, not the whole file: a bare scan for
+    # quoted dot-words also caught the default build folder, `".docgen"`.
+    ext_line = next((ln for ln in text.splitlines() if ln.startswith("- `ext`:")), "")
+    listed = set(re.findall(r'"(\.[a-z]+)"', ext_line))
+    check("the ext list names exactly the extensions code reads",
+          listed == set(code_ex.LANGUAGES), f"doc {sorted(listed)} vs code {sorted(code_ex.LANGUAGES)}")
+    check("every step spot is named",
+          all(named(f"step-{sid}") for sid, _ in build_mod.STEP_LABELS))
+
+    # Every example a model is shown must be one that loads. The shipped
+    # examples use a fixed set of paths, created here as stand-ins.
+    proj = Path(tmp.name) / "contract-project"
+    for d in ("src", "web/src"):
+        (proj / d).mkdir(parents=True, exist_ok=True)
+    for f in ("doc/contracts/openapi.yaml", "schema/schema.json", "recordings/session.har"):
+        (proj / f).parent.mkdir(parents=True, exist_ok=True)
+        (proj / f).write_text("{}")
+    blocks = re.findall(r"```toml\n(.*?)```", text, re.S)
+    failures = []
+    for i, block in enumerate(blocks):
+        path = proj / f"example-{i}.toml"
+        path.write_text(block)
+        try:
+            cfg.load(path)
+        except cfg.ConfigError as e:
+            failures.append(f"example {i}: {e.problems[:2]}")
+    check(f"every toml example in it loads ({len(blocks)})", blocks and not failures, failures)
+
+    # The error table is what a model uses to repair a refused file, so every
+    # message it quotes has to be one the code can actually produce.
+    source = "".join((HERE / "book" / f).read_text() for f in ("config.py", "notes.py"))
+    table = text.split("## When the build refuses your file")[-1]
+    # Every backticked message in the first column — a cell can hold two.
+    quoted = [m for row in table.splitlines() if row.startswith("| `")
+              for m in re.findall(r"`([^`]+)`", row.split("|")[1])]
+    unknown = []
+    for message in quoted:
+        fragments = [f.strip() for f in re.split(r"'[^']*'|…|\.sh", message) if f.strip()]
+        if not all(frag in source for frag in fragments):
+            unknown.append(message)
+    check(f"every error in its repair table is one the loaders produce ({len(quoted)})",
+          quoted and not unknown, unknown)
+
+    env = dict(__import__("os").environ, PYTHONPATH=str(HERE.parent))
+    printed = _sub.run([sys.executable, "-m", PKG, "contract"], capture_output=True,
+                       text=True, env=env)
+    check("`contract` prints it verbatim", printed.returncode == 0 and printed.stdout == text)
+
+
+_contract()
+
+
 print(f"{len(PASS)} passed, {len(FAIL)} failed, {len(SKIP)} skipped")
 if FAIL:
     print("\nfailed:")