houdinimd-docs 0.1.0__tar.gz

houdinimd_docs-0.1.0/PKG-INFO

@@ -0,0 +1,45 @@
+Metadata-Version: 2.4
+Name: houdinimd-docs
+Version: 0.1.0
+Classifier: Programming Language :: Rust
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Multimedia :: Graphics :: 3D Modeling
+Summary: Houdini's own documentation, read out of the install on this machine.
+Keywords: houdini,documentation,sidefx
+Author: JTCHE
+License-Expression: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://houdinimd.com
+
+# houdinimd-docs
+
+Houdini's own documentation, read out of the Houdini install on this machine.
+It is the documentation engine of the [HoudiniMD](https://houdinimd.com)
+desktop app, compiled from Rust into a Python module. The
+[HoudiniMCP](https://github.com/JTCHE/houdini-mcp) bridge uses it.
+
+No documentation ships in this package. Every page comes from the help files
+of an installed Houdini, so the text matches that build exactly.
+
+```python
+import houdinimd_docs
+
+docs = houdinimd_docs.Docs("/path/to/a/folder/for/the/index")
+docs.installs()                          # the Houdini builds found, newest first
+docs.page("nodes/sop/copytopoints")      # one page, as Markdown
+docs.search("copy to points", limit=5)   # ranked full-text search
+docs.page("hom/hou/Node", build="21.0.829")
+```
+
+Every call returns a JSON string. `page` raises `ValueError` when the build
+has no such page.
+
+The first search on a build indexes it into a SQLite file in the folder you
+name, which takes a few seconds. The index stays there, so this happens once
+per build. A page read never waits for it.
+
+Without `build`, the reader uses the Houdini in `$HFS`, then the newest build
+it finds. The build comes from the install's own `SYS_Version.h`, never from
+its folder name.
+

houdinimd_docs-0.1.0/README.md

@@ -0,0 +1,30 @@
+# houdinimd-docs
+
+Houdini's own documentation, read out of the Houdini install on this machine.
+It is the documentation engine of the [HoudiniMD](https://houdinimd.com)
+desktop app, compiled from Rust into a Python module. The
+[HoudiniMCP](https://github.com/JTCHE/houdini-mcp) bridge uses it.
+
+No documentation ships in this package. Every page comes from the help files
+of an installed Houdini, so the text matches that build exactly.
+
+```python
+import houdinimd_docs
+
+docs = houdinimd_docs.Docs("/path/to/a/folder/for/the/index")
+docs.installs()                          # the Houdini builds found, newest first
+docs.page("nodes/sop/copytopoints")      # one page, as Markdown
+docs.search("copy to points", limit=5)   # ranked full-text search
+docs.page("hom/hou/Node", build="21.0.829")
+```
+
+Every call returns a JSON string. `page` raises `ValueError` when the build
+has no such page.
+
+The first search on a build indexes it into a SQLite file in the folder you
+name, which takes a few seconds. The index stays there, so this happens once
+per build. A page read never waits for it.
+
+Without `build`, the reader uses the Houdini in `$HFS`, then the newest build
+it finds. The build comes from the install's own `SYS_Version.h`, never from
+its folder name.

houdinimd_docs-0.1.0/engine/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "engine"
+version = "0.1.0"
+edition = "2024"
+rust-version = "1.85"
+description = "Reads Houdini help out of an install: pages, index and search."
+
+[dependencies]
+serde = { version = "1", features = ["derive"] }
+serde_json = "1"
+zip = { version = "7.2.0", default-features = false, features = ["deflate"] }
+wiki = { version = "0.1.0", path = "../wiki" }
+rusqlite = { version = "0.40.2", features = ["bundled"] }
+rayon = "1.12.0"
+
+[target."cfg(windows)".dependencies]
+windows-sys = { version = "0.61.2", features = ["Win32_System_Threading"] }
+winreg = "0.56.0"

houdinimd_docs-0.1.0/engine/src/assets.rs

@@ -0,0 +1,276 @@
+//! Turns a reference written beside a help page into the path the app reads:
+//! a picture or video for the `himage` protocol, and a link for the router.
+//!
+//! A page writes its assets the way the SideFX help server serves them, which
+//! is not the way the install stores them:
+//!
+//! - `/images/playbar/timeline.png` is `playbar/timeline.png` in `images.zip`.
+//! - `../images/BasisSOP.jpg` on `nodes/sop/basis` is `nodes/BasisSOP.jpg` in
+//!   the same zip. The `images` segment is a serving path, not a folder.
+//! - `/videos/tween.webm` is a loose file under `$HFS/houdini/help/videos`.
+//! - `/movies/rotate.gif` is the same shape as `videos`, under the name a
+//!   package's own help folder uses for it — SideFX Labs ships no `videos/`.
+//!
+//! All three come back as one shape, `images/…`, `videos/…` or `movies/…`, so
+//! the protocol handler has one thing to read and the front-end has nothing
+//! to know.
+
+use wiki::{Block, Inline, LinkTarget};
+
+/// The asset path for `src` as written on the page at `page`, or `None` when
+/// the reference names nothing this app can read.
+pub fn resolve(page: &str, src: &str) -> Option<String> {
+    // `opdef:` and `./MainImage.jpg` name a picture inside an HDA, which is
+    // not a file in the install. Only the pages about writing help use them.
+    if src.starts_with("opdef:") || src.contains('?') || src.is_empty() {
+        return None;
+    }
+
+    let mut parts: Vec<&str> = Vec::new();
+    if !src.starts_with('/') {
+        // A relative reference stands beside the page, so the page's own name
+        // is not part of the base.
+        let dir = page
+            .trim_matches('/')
+            .rsplit_once('/')
+            .map_or("", |(d, _)| d);
+        parts.extend(dir.split('/'));
+    }
+    parts.extend(src.split('/'));
+
+    let mut path: Vec<&str> = Vec::new();
+    for part in parts {
+        match part {
+            "" | "." => {}
+            ".." => {
+                path.pop()?;
+            }
+            part => path.push(part),
+        }
+    }
+
+    // The first `images`, `videos` or `movies` segment says which store holds
+    // the file. Everything before it is the section the page lives in, which
+    // the store keeps as its own top folder.
+    let at = path.iter().position(|p| *p == "images" || *p == "videos" || *p == "movies")?;
+    let store = path.remove(at);
+    if path.len() <= at {
+        return None;
+    }
+    Some(format!("{store}/{}", path.join("/")))
+}
+
+/// The app path for a wiki link written beside the page rather than from the
+/// help root. `news/22/index` writes `[Solaris|solaris]`, and that means
+/// `/news/22/solaris`, not a page under the index.
+///
+/// ponytail: the base is the folder the page name sits in, so a page read at
+/// its folder form (`news/22` instead of `news/22/index`) bases one level too
+/// high. The index writes the `/index` form for every folder page, so only a
+/// hand-written address reaches the other one.
+pub fn link(page: &str, target: &str) -> Option<String> {
+    if target.is_empty() || target.starts_with('/') {
+        return None;
+    }
+    let dir = page
+        .trim_matches('/')
+        .rsplit_once('/')
+        .map_or("", |(dir, _)| dir);
+
+    let mut path: Vec<&str> = Vec::new();
+    for part in dir.split('/').chain(target.split('/')) {
+        match part {
+            "" | "." => {}
+            ".." => {
+                path.pop()?;
+            }
+            part => path.push(part),
+        }
+    }
+    // A single segment is a section, not a page, and nothing links to one.
+    if path.len() < 2 {
+        return None;
+    }
+    Some(format!("/{}", path.join("/")))
+}
+
+/// Rewrites every asset reference in a page to the path the `himage` protocol
+/// reads. A reference that names nothing readable is dropped, so the reader
+/// gets the text without a broken frame in the middle of it.
+pub fn rewrite(page: &str, blocks: &mut [Block], name_of: &dyn Fn(&str) -> Option<String>) {
+    for block in blocks {
+        match block {
+            Block::Item {
+                name,
+                label,
+                props,
+                children,
+            } => {
+                if name == "video" {
+                    for (key, value) in props.iter_mut() {
+                        if key == "src" {
+                            *value = resolve(page, value).unwrap_or_default();
+                        }
+                    }
+                }
+                inlines(page, label, name_of);
+                rewrite(page, children, name_of);
+            }
+            Block::Heading {
+                title, children, ..
+            } => {
+                inlines(page, &mut title.main, name_of);
+                rewrite(page, children, name_of);
+            }
+            Block::Section { children, .. } => rewrite(page, children, name_of),
+            Block::Definition { term, children, .. } => {
+                inlines(page, term, name_of);
+                rewrite(page, children, name_of);
+            }
+            Block::Usage { children, .. } => rewrite(page, children, name_of),
+            Block::Paragraph { text } | Block::Summary { text } => inlines(page, text, name_of),
+            Block::Subtopic { link, children } => {
+                inlines(page, link, name_of);
+                rewrite(page, children, name_of);
+            }
+            Block::Bullets { items } | Block::Numbers { items } => {
+                for item in items {
+                    rewrite(page, &mut item.blocks, name_of);
+                }
+            }
+            Block::Table { rows } => {
+                for row in rows {
+                    for cell in row {
+                        rewrite(page, &mut cell.blocks, name_of);
+                    }
+                }
+            }
+            Block::Html { children, .. } => rewrite(page, children, name_of),
+            Block::Divider { children, .. } => rewrite(page, children, name_of),
+            Block::Code { .. }
+            | Block::Include { .. }
+            | Block::RawHtml { .. } => {}
+        }
+    }
+}
+
+fn inlines(page: &str, inlines: &mut Vec<Inline>, name_of: &dyn Fn(&str) -> Option<String>) {
+    inlines.retain_mut(|inline| match inline {
+        Inline::Image { src } => match resolve(page, src) {
+            Some(path) => {
+                *src = path;
+                true
+            }
+            None => false,
+        },
+        Inline::Bold { body } | Inline::Italic { body } | Inline::Ui { body } => {
+            self::inlines(page, body, name_of);
+            true
+        }
+        Inline::Link { text, target } => {
+            if let LinkTarget::Wiki { path, .. } = target {
+                // `[intro]` names a page and shows the address; SideFX shows
+                // the page's title there instead.
+                let bare = matches!(text.as_slice(), [Inline::Text { text }] if text == path);
+                if let Some(resolved) = link(page, path) {
+                    *path = resolved;
+                }
+                if bare && let Some(found) = name_of(path) {
+                    *text = vec![Inline::Text { text: found }];
+                }
+            }
+            self::inlines(page, text, name_of);
+            true
+        }
+        _ => true,
+    });
+}
+
+#[cfg(test)]
+mod tests {
+    use super::{link, resolve};
+
+    #[test]
+    fn a_relative_link_stands_beside_its_page() {
+        assert_eq!(
+            link("news/22/index", "solaris").as_deref(),
+            Some("/news/22/solaris")
+        );
+        assert_eq!(
+            link("news/22/karma", "solaris").as_deref(),
+            Some("/news/22/solaris")
+        );
+        assert_eq!(
+            link("nodes/sop/box", "../../vex/functions/lerp").as_deref(),
+            Some("/vex/functions/lerp")
+        );
+    }
+
+    #[test]
+    fn an_absolute_link_is_left_alone() {
+        assert_eq!(link("news/22/index", "/nodes/sop/box"), None);
+        assert_eq!(link("news/22/index", ""), None);
+    }
+
+    #[test]
+    fn a_link_that_leaves_the_help_root_is_refused() {
+        assert_eq!(link("news/22/index", "../../../elsewhere"), None);
+        assert_eq!(link("news/index", "solaris").as_deref(), Some("/news/solaris"));
+    }
+
+    #[test]
+    fn absolute_image_drops_the_serving_folder() {
+        assert_eq!(
+            resolve("basics/playbar", "/images/playbar/timeline.png").as_deref(),
+            Some("images/playbar/timeline.png")
+        );
+    }
+
+    #[test]
+    fn a_relative_image_keeps_the_section_it_came_from() {
+        assert_eq!(
+            resolve("nodes/sop/basis", "../images/BasisSOP.jpg").as_deref(),
+            Some("images/nodes/BasisSOP.jpg")
+        );
+        assert_eq!(
+            resolve("nodes/cop2/rotoshape", "../images/RotoShapeEditMode.jpg").as_deref(),
+            Some("images/nodes/RotoShapeEditMode.jpg")
+        );
+    }
+
+    #[test]
+    fn an_empty_segment_is_not_a_folder() {
+        assert_eq!(
+            resolve(
+                "nodes/lop/rendergeometrysettings",
+                "//images/solaris/kug/a.jpg"
+            )
+            .as_deref(),
+            Some("images/solaris/kug/a.jpg")
+        );
+    }
+
+    #[test]
+    fn a_video_reads_from_the_videos_folder() {
+        assert_eq!(
+            resolve("anim/animtoolbar", "/videos/animtoolbar_tween.webm").as_deref(),
+            Some("videos/animtoolbar_tween.webm")
+        );
+    }
+
+    #[test]
+    fn a_picture_inside_an_asset_is_not_a_file() {
+        assert_eq!(resolve("help/nodes", "opdef:.?test.png"), None);
+        assert_eq!(
+            resolve("help/nodes", "opdef:matt::Sop/e::1.0?test.png"),
+            None
+        );
+        assert_eq!(resolve("help/nodes", "./MainImage.jpg"), None);
+    }
+
+    #[test]
+    fn a_reference_that_leaves_the_help_root_is_refused() {
+        assert_eq!(resolve("basics/playbar", "../../../images/x.png"), None);
+        assert_eq!(resolve("basics/playbar", "/images"), None);
+    }
+}

houdinimd_docs-0.1.0/engine/src/db.rs

@@ -0,0 +1,137 @@
+//! `index.db`: what the engine derives from a Houdini install.
+//!
+//! Everything here is derived. Delete the file and nothing of the reader's is
+//! lost — the background pass fills it again in seconds. The reader's own work
+//! lives in `user.db`, which the app owns and this module never touches.
+//!
+//! See spec: Local — SQLite FTS5 Index.
+
+use std::path::{Path, PathBuf};
+
+use rusqlite::Connection;
+
+/// `index.db` sits in the folder the caller names.
+pub fn path(data: &Path) -> PathBuf {
+    data.join("index.db")
+}
+
+/// Opens `index.db` and makes its schema.
+pub fn open(data: &Path) -> Result<Connection, String> {
+    std::fs::create_dir_all(data).map_err(|e| format!("{}: {e}", data.display()))?;
+    let index = path(data);
+    let db = Connection::open(&index).map_err(|e| format!("{}: {e}", index.display()))?;
+
+    // WAL lets the background indexer write while the reader reads.
+    db.pragma_update(None, "journal_mode", "WAL")
+        .map_err(|e| e.to_string())?;
+    db.pragma_update(None, "synchronous", "NORMAL")
+        .map_err(|e| e.to_string())?;
+
+    reset_if_stale(&db)?;
+    db.execute_batch(SCHEMA).map_err(|e| e.to_string())?;
+    Ok(db)
+}
+
+/// What `SCHEMA` describes. Raise it whenever the derived tables change shape,
+/// or the parser writes different rows into them.
+const VERSION: u32 = 3;
+
+/// Throws away everything derived from the Houdini install when the shape it
+/// was written in is not the shape this build reads. `index.db` is derived, so
+/// there is nothing here to migrate — the background pass fills it again in
+/// seconds.
+fn reset_if_stale(db: &Connection) -> Result<(), String> {
+    let found: u32 = db
+        .query_row("PRAGMA user_version", [], |row| row.get(0))
+        .map_err(|e| e.to_string())?;
+    if found != VERSION {
+        db.execute_batch(
+            "DROP TABLE IF EXISTS pages;
+             DROP TABLE IF EXISTS pages_fts;
+             DROP TABLE IF EXISTS builds;",
+        )
+        .map_err(|e| e.to_string())?;
+        db.pragma_update(None, "user_version", VERSION)
+            .map_err(|e| e.to_string())?;
+    }
+    Ok(())
+}
+
+/// One build is one set of rows, never one file and never one folder. A
+/// Houdini upgrade rewrites its own rows and leaves the others alone.
+const SCHEMA: &str = r#"
+CREATE TABLE IF NOT EXISTS builds (
+  build TEXT PRIMARY KEY,
+  pages INTEGER NOT NULL DEFAULT 0,
+  -- 0 while the background pass is still filling this build in.
+  done  INTEGER NOT NULL DEFAULT 0
+);
+
+CREATE TABLE IF NOT EXISTS pages (
+  build     TEXT NOT NULL,
+  path      TEXT NOT NULL,
+  title     TEXT NOT NULL,
+  node_type TEXT,
+  icon      TEXT,
+  summary   TEXT,
+  PRIMARY KEY (build, path)
+) WITHOUT ROWID;
+
+-- One row per SECTION of a page, not per page: a hit names the heading the
+-- reader should land on, which is what the result list draws under the page.
+-- Cutting the body at its headings stores it once, not twice — see
+-- `sections.rs`.
+--
+-- `heading` is empty and `title` is set on the row for the text above the first
+-- heading, so a page is named exactly once and the title weight cannot multiply
+-- with the number of sections it has.
+CREATE VIRTUAL TABLE IF NOT EXISTS pages_fts USING fts5(
+  build   UNINDEXED,
+  path    UNINDEXED,
+  slug    UNINDEXED,
+  heading,
+  title,
+  body,
+  tokenize = "unicode61 remove_diacritics 2"
+);
+"#;
+
+/// Turns what the reader typed into an FTS5 query.
+///
+/// Every token is quoted, so a bare `*`, `-` or `NEAR` is text and not syntax.
+/// The last token takes a prefix star, because the reader is still typing it.
+pub fn match_query(text: &str) -> Option<String> {
+    let tokens: Vec<String> = text
+        .split(|c: char| !c.is_alphanumeric() && c != '_')
+        .filter(|t| !t.is_empty())
+        .map(|t| format!("\"{t}\""))
+        .collect();
+    let (last, rest) = tokens.split_last()?;
+    let mut query = rest.join(" ");
+    if !query.is_empty() {
+        query.push(' ');
+    }
+    query.push_str(last);
+    query.push('*');
+    Some(query)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::match_query;
+
+    #[test]
+    fn a_query_quotes_every_token_and_extends_the_last() {
+        assert_eq!(match_query("copy to points").unwrap(), "\"copy\" \"to\" \"points\"*");
+    }
+
+    #[test]
+    fn syntax_the_reader_types_stays_text() {
+        assert_eq!(match_query("a OR b*").unwrap(), "\"a\" \"OR\" \"b\"*");
+    }
+
+    #[test]
+    fn nothing_to_match_is_no_query() {
+        assert!(match_query("   ").is_none());
+    }
+}

houdinimd_docs-0.1.0/engine/src/examples.rs

@@ -0,0 +1,66 @@
+//! The example files that ship for a node, as a section at the foot of its
+//! page.
+//!
+//! An example is a scene file plus a page beside it, under
+//! `help/examples/<node path>/`. The node page itself never names them —
+//! SideFX's doc build finds them by their place on the disk and writes the
+//! Examples section from what it finds. See spec: Local — Whole sections are
+//! dropped from pages.
+//!
+//! Not in the `wiki` crate: the crate reads no file, and this reads a
+//! directory. Same reason as `family.rs`. See `agents/architecture.md`.
+
+use std::path::Path;
+
+use wiki::model::ListItem;
+use wiki::{Block, Inline, LinkTarget};
+
+/// Appends an Examples section when the install ships examples for this page.
+///
+/// `path` is the page's own help path, `nodes/sop/file`. The examples for it
+/// sit under `examples/` at the same path.
+pub fn append(help: &Path, path: &str, blocks: &mut Vec<Block>) {
+    if path.starts_with("examples/") {
+        return;
+    }
+    let mut dir = help.join("examples");
+    for part in path.split('/') {
+        dir.push(part);
+    }
+    let Ok(entries) = std::fs::read_dir(&dir) else {
+        return;
+    };
+    let mut names: Vec<String> = entries
+        .flatten()
+        .filter_map(|entry| {
+            let file = entry.file_name().into_string().ok()?;
+            file.strip_suffix(".txt").map(str::to_string)
+        })
+        .collect();
+    if names.is_empty() {
+        return;
+    }
+    names.sort_unstable();
+
+    let items = names
+        .into_iter()
+        .map(|name| ListItem {
+            blocks: vec![Block::Paragraph {
+                text: vec![Inline::Link {
+                    text: vec![Inline::Text { text: name.clone() }],
+                    target: LinkTarget::Wiki {
+                        path: format!("/examples/{path}/{name}"),
+                        anchor: None,
+                    },
+                }],
+            }],
+            props: Vec::new(),
+        })
+        .collect();
+    blocks.push(Block::Section {
+        name: "examples".to_string(),
+        title: None,
+        props: Vec::new(),
+        children: vec![Block::Bullets { items }],
+    });
+}

houdinimd_docs-0.1.0/engine/src/family.rs

@@ -0,0 +1,118 @@
+//! The sibling list a VEX function or statement page carries at its foot:
+//! every other page that shares one of its `#tags`, one heading per tag.
+//!
+//! SideFX's own doc build writes this from a tag index that sits outside the
+//! page source, so the raw wiki markup never carries it — the app rebuilds it
+//! from its own reading of `vex.zip` instead. See spec: Local — VEX pages lose
+//! the family index.
+//!
+//! Not in the `wiki` crate: the crate reads no file, and this reads every VEX
+//! page once to answer one page. See `agents/architecture.md`.
+
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+use std::sync::{Arc, LazyLock, Mutex};
+
+use wiki::model::ListItem;
+use wiki::{Block, Inline, LinkTarget};
+
+struct Entry {
+    name: String,
+    tags: Vec<String>,
+}
+
+/// `vex.zip` read once per install and reused for every function page after
+/// the first. About 1,100 small pages; parsing them again for every page open
+/// would cost more than the page itself.
+static CACHE: LazyLock<Mutex<HashMap<PathBuf, Arc<Vec<Entry>>>>> =
+    LazyLock::new(|| Mutex::new(HashMap::new()));
+
+fn entries(help: &Path) -> Arc<Vec<Entry>> {
+    let zip = help.join("vex.zip");
+    let mut cache = CACHE.lock().expect("the family cache is not poisoned");
+    if let Some(found) = cache.get(&zip) {
+        return found.clone();
+    }
+    let built = Arc::new(read(&zip));
+    cache.insert(zip, built.clone());
+    built
+}
+
+fn read(zip: &Path) -> Vec<Entry> {
+    let names = crate::help::entries(zip, "functions/")
+        .into_iter()
+        .chain(crate::help::entries(zip, "statements/"));
+    let mut out = Vec::new();
+    for name in names {
+        let stem = name
+            .rsplit('/')
+            .next()
+            .unwrap_or(&name)
+            .trim_end_matches(".txt");
+        // A page written to be included by another, not a function of its own.
+        if stem.starts_with('_') {
+            continue;
+        }
+        let Some(source) = crate::help::text(zip, &name) else {
+            continue;
+        };
+        let (props, _) = wiki::blocks::parse_source(&source);
+        if !matches!(wiki::model::prop(&props, "type"), Some("vex" | "vexstatement")) {
+            continue;
+        }
+        let Some(tags) = wiki::model::prop(&props, "tags") else {
+            continue;
+        };
+        let tags = tags
+            .split(',')
+            .map(str::trim)
+            .filter(|t| !t.is_empty())
+            .map(str::to_string)
+            .collect();
+        out.push(Entry { name: stem.to_string(), tags });
+    }
+    out
+}
+
+/// Appends one `Block::Section` per tag the page carries, each an
+/// alphabetical list of every VEX function or statement with that tag
+/// (this page included), in the order the page's own `#tags` lists them.
+pub fn append(help: &Path, props: &wiki::Props, blocks: &mut Vec<Block>) {
+    if !matches!(wiki::model::prop(props, "type"), Some("vex" | "vexstatement")) {
+        return;
+    }
+    let Some(own_tags) = wiki::model::prop(props, "tags") else {
+        return;
+    };
+    let all = entries(help);
+    for tag in own_tags.split(',').map(str::trim).filter(|t| !t.is_empty()) {
+        let mut names: Vec<&str> = all
+            .iter()
+            .filter(|entry| entry.tags.iter().any(|t| t == tag))
+            .map(|entry| entry.name.as_str())
+            .collect();
+        names.sort_unstable();
+        names.dedup();
+        if names.is_empty() {
+            continue;
+        }
+        let items = names
+            .into_iter()
+            .map(|name| ListItem {
+                blocks: vec![Block::Paragraph {
+                    text: vec![Inline::Link {
+                        text: vec![Inline::Text { text: name.to_string() }],
+                        target: LinkTarget::Vex { name: name.to_string() },
+                    }],
+                }],
+                props: Vec::new(),
+            })
+            .collect();
+        blocks.push(Block::Section {
+            name: tag.to_string(),
+            title: None,
+            props: Vec::new(),
+            children: vec![Block::Bullets { items }],
+        });
+    }
+}