Commit `768e668f7a`

768e668f7aa715bf6d20f284cd6b9591ea029249

parent: bbe31403db

Verified · cmc

cmc <hello@cleberg.net> · 2026-08-11 21:07 UTC

0.19: full-content collections, and a listing that stops showing stale excerpts

`include_content = true` gives a listing template each entry's rendered HTML as
`entry.content`, which is what a feed needs: one that carries whole posts and
then quietly starts carrying excerpts is a downgrade its subscribers notice.

Bodies are rendered when the listing is rendered, not when it is built, so a
cached feed costs nothing — a no-op build of a 196-page site with a full-content
feed still takes 0.14s. The listing's cache key covers its entries' *source*
hashes, so a body edit reaches the feed without a render of every post to find
out whether it should.

Writing that turned up a defect underneath it. A listing's cache key was a
hand-picked set of entry fields, and the excerpt was not among them: rewriting a
post's opening paragraph left the old excerpt on the index until something
unrelated invalidated the page. Entries are now hashed through their
serialization, which cannot drift from what a template can read.

The test that would have caught it asserted the opposite — "editing a post's
body changes no listing metadata, so the index must not churn" — which was true
of the hash and false of the site. It now asserts that a body edit rebuilds the
listing showing its excerpt, and that it rebuilds nothing else.

`page.toc` entries carry `number` too, so a site with section numbering on can
number its contents list to match its headings, which is not something a
template can work out for itself.

Layout: unified · split

CHANGELOG.md +14

	@@ -15,6 +15,20 @@ Two conventions worth knowing before reading:
15	Versions follow the compatibility promise in the README: config keys, template variables,	15	Versions follow the compatibility promise in the README: config keys, template variables,
16	CLI flags and URLs are the stable surface.	16	CLI flags and URLs are the stable surface.
17		17
		18	## 0.19.0
		19
		20	- Full-content collections. `include_content = true` gives a listing template each
		21	entry's rendered HTML as `entry.content` — a feed that carries whole posts rather than
		22	excerpts. Rendered only when the listing is actually rebuilt, so a cached feed costs
		23	nothing.
		24	- Fixed: a listing could show a stale excerpt. Its cache key covered a hand-picked set
		25	of fields, and the excerpt was not among them, so rewriting a post's first paragraph
		26	left the old text on the index until something unrelated invalidated it. Entries are now
		27	hashed through their serialization, which cannot drift from what a template can read.
		28	Editing a post's body now rebuilds the listings that show it.
		29	- `page.toc` entries carry `number`, so a site with section numbering on can number its
		30	contents list to match its headings.
		31
18	## 0.18.0	32	## 0.18.0
19		33
20	Release engineering, so that a version number is worth reading.	34	Release engineering, so that a version number is worth reading.

Cargo.lock +1 −1

	@@ -675,7 +675,7 @@ dependencies = [
675		675
676	[[package]]	676	[[package]]
677	name = "org-ssg"	677	name = "org-ssg"
678	version = "0.18.0"	678	version = "0.19.0"
679	dependencies = [	679	dependencies = [
680	"anyhow",	680	"anyhow",
681	"blake3",	681	"blake3",

Cargo.toml +1 −1

	@@ -1,6 +1,6 @@
1	[package]	1	[package]
2	name = "org-ssg"	2	name = "org-ssg"
3	version = "0.18.0"	3	version = "0.19.0"
4	edition = "2021"	4	edition = "2021"
5	description = "Org-mode static site generator that renders the org element tree straight to HTML"	5	description = "Org-mode static site generator that renders the org element tree straight to HTML"
6	license = "MIT"	6	license = "MIT"

README.md +1 −1

	@@ -87,7 +87,7 @@ receive:
87	\| Variable \| What it is \|	87	\| Variable \| What it is \|
88	\|---\|---\|	88	\|---\|---\|
89	\| `body` \| the rendered page HTML — use `{{ body \\| safe }}` \|	89	\| `body` \| the rendered page HTML — use `{{ body \\| safe }}` \|
90	\| `page` \| `.title`, `.url`, `.source`, `.date`, `.date_iso`, `.year`, `.tags`, `.excerpt`, `.word_count`, `.reading_time`, `.toc`, `.keywords` \|	90	\| `page` \| `.title`, `.url`, `.source`, `.date`, `.date_iso`, `.year`, `.tags`, `.content`, `.excerpt`, `.word_count`, `.reading_time`, `.toc`, `.keywords` \|
91	\| `site` \| `.title`, `.base_url`, `.description`, `.language` \|	91	\| `site` \| `.title`, `.base_url`, `.description`, `.language` \|
92	\| `nav` \| list of `{title, url}`, relative to this page \|	92	\| `nav` \| list of `{title, url}`, relative to this page \|
93	\| `root` \| `../`-prefix back to the site root from this page \|	93	\| `root` \| `../`-prefix back to the site root from this page \|

docs/guide/03-collections.org +26

	@@ -78,6 +78,32 @@ Name that group in the template rather than with =groupby='s =default== argument
78	covers an attribute that is missing and not one that is null — an undated page has a	78	covers an attribute that is missing and not one that is null — an undated page has a
79	=year=, and it is =none=.	79	=year=, and it is =none=.
80		80
		81	** Full-content feeds
		82
		83	A feed usually carries whole posts, and a subscriber handed excerpts instead has lost
		84	something. =include_content= gives the template each entry's rendered HTML as
		85	=entry.content=:
		86
		87	#+BEGIN_SRC toml
		88	[[collections]]
		89	source = "blog"
		90	output = "feed.xml"
		91	template = "feed.xml"
		92	include_content = true
		93	#+END_SRC
		94
		95	#+BEGIN_SRC html
		96	<description><![CDATA[{{ post.content \| safe }}]]></description>
		97	#+END_SRC
		98
		99	Off by default, because it costs a render of every listed page each time the listing is
		100	rebuilt. That cost is only paid when the listing is not cached, and the listing's cache
		101	key covers its entries' content — so a body edit reaches the feed, and an unchanged site
		102	pays nothing.
		103
		104	Everywhere else =entry.content= is =none=, since carrying every page's body in every
		105	listing context would be most of a site's memory for nothing.
		106
81	** nav = true	107	** nav = true
82		108
83	The listing page joins the site navigation. This is how a section landing page — =/blog/=,	109	The listing page joins the site navigation. This is how a section landing page — =/blog/=,

docs/guide/04-templates.org +6 −2

 The page's headings as a *tree* — a table of contents is one, and rebuilding a tree from
 a flat list of levels inside a template is what Jinja is worst at.
-Each entry has =title=, =anchor=, =level= and =children=:
+Each entry has =title=, =anchor=, =level=, =number= and =children=:
 #+BEGIN_SRC html
 {% macro toc_list(entries) %}
 <ul>{% for e in entries %}
-  <li><a href="#{{ e.anchor }}">{{ e.title }}</a>
+  <li><a href="#{{ e.anchor }}">{{ e.number }} {{ e.title }}</a>
   {%- if e.children %}{{ toc_list(e.children) }}{% endif %}</li>
 {% endfor %}</ul>
 {% endmacro %}
 {% if page.toc | length > 1 %}{{ toc_list(page.toc) }}{% endif %}
 #+END_SRC
+=number= is the section number — =1.=, =3.1.= — always computed and printed only if you
+ask for it. Print it when =[html] section_numbers= is on, or the contents will number what
+the headings do not.
 Anchors come from the same function that emits heading =id= attributes, so a TOC link
 cannot drift from the heading it points at. The tree is empty when the page has no
 headings, when =[html] toc = false=, or when the document says =#+OPTIONS: toc:nil=.

src/config.rs +8

     /// `{tag}` as well when the collection is grouped — otherwise page 2 of one group
     /// would overwrite page 2 of another.
     pub paginate_output: Utf8PathBuf,
+    /// Give the template each entry's rendered HTML as `entry.content`.
+    ///
+    /// Off by default, and only worth turning on for a feed: it renders every listed
+    /// page's body whenever the listing is rebuilt. A reader subscribed to a
+    /// full-content feed and then handed excerpts has lost something, which is the one
+    /// case where that cost is the right trade.
+    pub include_content: bool,
     /// Add this listing page to the site navigation. This is how a section landing page
     /// — `/blog/`, `/notes/` — gets into a nav built from top-level pages.
     pub nav: bool,
             order: SortOrder::default(),
             paginate: 0,
             paginate_output: Utf8PathBuf::new(),
+            include_content: false,
             nav: false,
         }
     }

src/main.rs +1

	@@ -317,6 +317,7 @@ fn build_file(input: &Utf8Path, output: &Utf8Path) -> Result<()> {
317	year: None,	317	year: None,
318	tags: Vec::new(),	318	tags: Vec::new(),
319	excerpt: String::new(),	319	excerpt: String::new(),
		320	content: None,
320	word_count: 0,	321	word_count: 0,
321	reading_time: 0,	322	reading_time: 0,
322	keywords: Default::default(),	323	keywords: Default::default(),

src/site.rs +92 −11

     groups: Vec<GroupContext>,
     /// Set when this is one page of a paginated listing.
     paginator: Option<Paginator>,
+    /// Render each entry's body into `entry.content` (see
+    /// [`Collection::include_content`](crate::config::Collection::include_content)).
+    include_content: bool,
+    /// Content hash of each entry's source, in `entries` order. Not shown to templates —
+    /// it is how a content-carrying listing notices that a body it embeds has changed,
+    /// without rendering every body to find out.
+    entry_hashes: Vec<ContentHash>,
 }
 /// Split one listing's entries across numbered pages, appending each as its own
 /// changes — only pages 2..N are named by `paginate_output`. An empty listing still
 /// emits page 1, because a section that exists but has nothing in it should be a page
 /// saying so rather than a 404.
+#[allow(clippy::too_many_arguments)]
 fn push_paginated(
     listings: &mut Vec<Listing>,
     collection: &config::Collection,
     output: Utf8PathBuf,
     title: String,
     entries: Vec<PageContext>,
+    entry_hashes: Vec<ContentHash>,
     group: Option<GroupContext>,
     groups: Vec<GroupContext>,
 ) {
             group,
             groups,
             paginator: None,
+            include_content: collection.include_content,
+            entry_hashes: entry_hashes.clone(),
         });
         return;
     }
         listings.push(Listing {
             output: here.clone(),
             template: collection.template.clone(),
+            include_content: collection.include_content,
+            entry_hashes: entry_hashes.clone(),
             title: title.clone(),
             entries: chunk.to_vec(),
             group: group.clone(),
 /// Build the listing pages a config asks for, each with its entries sorted.
 fn build_listings(config: &Config, preps: &[PagePrep]) -> Result<Vec<Listing>> {
     let mut listings = Vec::new();
+    let hashes: HashMap<&str, ContentHash> = preps
+        .iter()
+        .map(|p| (p.source.as_str(), p.content_hash))
+        .collect();
+    let hashes_of = |entries: &[PageContext]| -> Vec<ContentHash> {
+        entries
+            .iter()
+            .filter_map(|e| hashes.get(e.source.as_str()).copied())
+            .collect()
+    };
     for collection in &config.collections {
         let mut entries: Vec<PageContext> = preps
             .iter()
         }
         if collection.group_by.is_empty() {
+            let entry_hashes = hashes_of(&entries);
             push_paginated(
                 &mut listings,
                 collection,
                 collection.output.clone(),
                 collection.title.clone(),
                 entries,
+                entry_hashes,
                 None,
                 Vec::new(),
             );
         if !collection.output.as_str().is_empty() {
             for group in &groups {
+                let members_of = members.get(&group.name).cloned().unwrap_or_default();
+                let entry_hashes = hashes_of(&members_of);
                 push_paginated(
                     &mut listings,
                     collection,
                     collection
                         .title
                         .replace(config::GROUP_PLACEHOLDER, &group.name),
-                    members.get(&group.name).cloned().unwrap_or_default(),
+                    members_of,
+                    entry_hashes,
                     Some(group.clone()),
                     // Deliberately not the whole group list. A page that can see every
                     // group depends on every group, so one new post would re-render every
                 group: None,
                 groups: groups.clone(),
                 paginator: None,
+                // A group index lists groups, not pages; there are no bodies to carry.
+                include_content: false,
+                entry_hashes: Vec::new(),
             });
         }
     }
 /// Everything a listing template can see about its entries, hashed. This is the listing
 /// page's whole dependency: if none of these change, its output cannot have changed.
+///
+/// Entries are hashed through their *serialization* rather than a hand-picked set of
+/// fields. Picking fields means the hash drifts from what a template can read the moment
+/// one is added — which it had: the excerpt was missing, so rewriting a post's first
+/// paragraph left the old excerpt on the index until something else invalidated it.
 fn listing_entries_hash(listing: &Listing) -> Hash {
-    let fields: Vec<(String, String)> = listing
+    let mut fields: Vec<(String, String)> = listing
         .entries
         .iter()
-        .flat_map(|e| {
+        .map(|e| {
-            [
+            (
-                (e.url.clone(), e.title.clone()),
+                e.url.clone(),
-                (
+                serde_json::to_string(e).unwrap_or_else(|_| e.title.clone()),
-                    e.date.clone().unwrap_or_default(),
+            )
-                    e.tags.join(",") + "\u{0}" + &e.keywords.len().to_string(),
-                ),
-            ]
         })
         // A group index has no entries at all — its content *is* the group list, so the
         // groups have to be in the hash or a tag index would never notice a new tag.
         }))
         .chain([(listing.title.clone(), listing.template.clone())])
         .collect();
+    // A listing that embeds its entries' bodies depends on those bodies. The source hash
+    // stands in for the rendered HTML, so noticing a change does not cost a render of
+    // every page listed.
+    if listing.include_content {
+        fields.extend(
+            listing
+                .entry_hashes
+                .iter()
+                .map(|h| ("content".to_string(), format!("{h:?}"))),
+        );
+    }
     // Entry *order* is meaningful in a listing, so this hashes the sorted-by-us sequence
     // rather than a set: a re-ordering is a real change to the page.
     site_structure_hash_ordered(&fields)
 }
+/// A listing's entries with their rendered bodies attached, for a template that asked
+/// for them — a full-content feed being the case that needs it.
+///
+/// An entry whose source is not among the prepared pages keeps `content: none` rather
+/// than failing: the listing is still a valid page, and a feed item without a body is a
+/// better outcome than no feed.
+fn entries_with_content(
+    entries: &[PageContext],
+    preps: &[PagePrep],
+    highlighter: &SyntectHighlighter,
+    config: &Config,
+) -> Vec<PageContext> {
+    let by_source: HashMap<&str, &PagePrep> =
+        preps.iter().map(|p| (p.source.as_str(), p)).collect();
+    let opts = render_options(config);
+    entries
+        .par_iter()
+        .map(|entry| {
+            let mut entry = entry.clone();
+            if let Some(prep) = by_source.get(entry.source.as_str()) {
+                let Html(html) = render_with(&prep.resolved, highlighter, &opts);
+                entry.content = Some(html);
+            }
+            entry
+        })
+        .collect()
+}
 /// The nav a listing page shows: whatever the site's nav is, relativized to this
 /// listing's own location.
 fn listing_nav(preps: &[PagePrep], output: &Utf8Path) -> Vec<NavItem> {
         year: None,
         tags: Vec::new(),
         excerpt: String::new(),
+        content: None,
         word_count: 0,
         reading_time: 0,
         keywords: Default::default(),
             let stylesheet = format!("{root}{SYNTAX_STYLESHEET}");
             let nav = listing_nav(&preps, &listing.output);
             let page_ctx = listing_context(listing);
+            // Bodies are rendered here rather than when the listing was built, so a
+            // cached feed costs nothing. This is the only place a page is rendered twice.
+            let with_content = listing
+                .include_content
+                .then(|| entries_with_content(&listing.entries, &preps, &highlighter, &cfg));
             let mut ctx = RenderContext::new(&site, &page_ctx, &nav, &stylesheet, &root);
-            ctx.pages = Some(&listing.entries);
+            ctx.pages = Some(with_content.as_deref().unwrap_or(&listing.entries));
             ctx.group = listing.group.as_ref();
             ctx.groups = &listing.groups;
             ctx.paginator = listing.paginator.as_ref();
             .filter(|d| !d.trim().is_empty())
             .or_else(|| first_paragraph(&doc.root))
             .unwrap_or_default(),
+        content: None,
         word_count: words,
         reading_time: words.div_ceil(WORDS_PER_MINUTE).max(usize::from(words > 0)),
         toc: if option_enabled(&doc.keywords, "toc", config.html.toc) {

src/template.rs +4

     /// Every `#+KEYWORD:` in the file, keyed by lowercased name, so a template can use
     /// project-specific metadata this crate has never heard of.
     pub keywords: BTreeMap<String, String>,
+    /// The page's rendered HTML, when a collection asked for it with
+    /// `include_content`. `none` everywhere else, because carrying every page's body in
+    /// every listing context would be most of a site's memory for nothing.
+    pub content: Option<String>,
     /// The page's headings as a tree. Empty when the page has none, when the site turns
     /// `html.toc` off, or when the document opts out with `#+OPTIONS: toc:nil`.
     pub toc: Vec<crate::util::TocEntry>,

src/util.rs +22 −9

     pub anchor: String,
     /// Org heading level, 1-based, before any `heading_offset` is applied.
     pub level: u8,
+    /// This entry's section number — `1.`, `3.1.` — always computed, printed only by a
+    /// template that wants it. A site with `section_numbers` on and an unnumbered
+    /// contents list reads as a mistake, and the numbers cannot be derived in Jinja
+    /// without rebuilding the tree walk that produced them.
+    pub number: String,
     pub children: Vec<TocEntry>,
 }
 /// Nested rather than flat: a table of contents *is* a tree, and reconstructing one from
 /// a flat list of levels inside a template is the kind of thing Jinja is bad at.
 pub fn table_of_contents(root: &Section) -> Vec<TocEntry> {
-    root.children.iter().map(toc_entry).collect()
+    numbered_entries(&root.children, "")
 }
-fn toc_entry(section: &Section) -> TocEntry {
+fn numbered_entries(sections: &[Section], prefix: &str) -> Vec<TocEntry> {
-    let heading = section.heading.as_ref();
+    sections
-    TocEntry {
+        .iter()
-        title: heading.map(|h| plain_text(&h.title)).unwrap_or_default(),
+        .enumerate()
-        anchor: heading.map(heading_anchor).unwrap_or_default(),
+        .map(|(i, section)| {
-        level: heading.map(|h| h.level).unwrap_or(1),
+            let number = format!("{prefix}{}.", i + 1);
-        children: section.children.iter().map(toc_entry).collect(),
+            let heading = section.heading.as_ref();
-    }
+            TocEntry {
+                title: heading.map(|h| plain_text(&h.title)).unwrap_or_default(),
+                anchor: heading.map(heading_anchor).unwrap_or_default(),
+                level: heading.map(|h| h.level).unwrap_or(1),
+                children: numbered_entries(&section.children, &format!("{prefix}{}.", i + 1)),
+                number,
+            }
+        })
+        .collect()
 }
 /// Parse `#+OPTIONS:` into its `key:value` switches.

tests/config.rs +96 −7

	@@ -673,27 +673,48 @@ fn adding_a_post_rebuilds_only_the_listing_and_the_post() {
673	);	673	);
674	}	674	}
675		675
676	/// Editing a post's body changes no listing metadata, so the index must not churn.	676	/// Editing a post's body reaches its listing, because a listing shows things derived
677	#[test]	677	/// from the body: the excerpt is its first paragraph, and the reading time is its length.
678	fn editing_a_post_body_does_not_rebuild_the_listing() {	678	///
		679	/// This test used to assert the opposite, and the site was wrong for it — rewriting a
		680	/// post's opening paragraph left the old excerpt on the index until something unrelated
		681	/// invalidated it. A listing depends on everything its template can read.
		682	#[test]
		683	fn editing_a_post_body_rebuilds_the_listing_that_shows_its_excerpt() {
679	let root = tmpdir("listbody");	684	let root = tmpdir("listbody");
680	let src = root.join("src");	685	let src = root.join("src");
681	std::fs::create_dir_all(&src).unwrap();	686	std::fs::create_dir_all(&src).unwrap();
682	write_blog(&src, "");	687	write_blog(&src, "");
		688	std::fs::write(
		689	src.join("templates/list.html"),
		690	"<html><body>{% for p in pages %}<li>{{ p.excerpt }}</li>{% endfor %}</body></html>",
		691	)
		692	.unwrap();
683	let out = root.join("out");	693	let out = root.join("out");
684	build(&src, &out);	694	build(&src, &out);
685		695
686	std::fs::write(	696	std::fs::write(
687	src.join("blog/mid.org"),	697	src.join("blog/mid.org"),
688	"#+TITLE: Middle Post\n#+DATE: 2024-08-05\n\nEdited body.\n",	698	"#+TITLE: Middle Post\n#+DATE: 2024-08-05\n\nA completely different opening.\n",
689	)	699	)
690	.unwrap();	700	.unwrap();
691	let report = build(&src, &out);	701	let report = build(&src, &out);
692		702
		703	assert!(
		704	report.rendered.contains(&Utf8PathBuf::from("blog/index.html")),
		705	"the listing rebuilt: {:?}",
		706	report.rendered
		707	);
		708	assert!(
		709	page(&out, "blog/index.html").contains("A completely different opening."),
		710	"and shows the new excerpt:\n{}",
		711	page(&out, "blog/index.html")
		712	);
693	assert_eq!(	713	assert_eq!(
694	report.rendered,	714	report.rendered.len(),
695	vec![Utf8PathBuf::from("blog/mid.html")],	715	2,
696	"only the post itself; the listing shows unchanged metadata"	716	"the post and its listing, and nothing else: {:?}",
		717	report.rendered
697	);	718	);
698	}	719	}
699		720
	@@ -2289,3 +2310,71 @@ fn a_missing_asset_root_is_an_error() {
2289	.expect_err("a missing asset root must fail");	2310	.expect_err("a missing asset root must fail");
2290	assert!(format!("{err:#}").contains("nope"), "names it: {err:#}");	2311	assert!(format!("{err:#}").contains("nope"), "names it: {err:#}");
2291	}	2312	}
		2313
		2314	/// A feed that carries excerpts where it used to carry whole posts is a downgrade its
		2315	/// subscribers notice. `include_content` gives the template each entry's rendered HTML.
		2316	#[test]
		2317	fn a_collection_can_carry_its_entries_rendered_bodies() {
		2318	let root = tmpdir("feedcontent");
		2319	let src = root.join("src");
		2320	std::fs::create_dir_all(&src).unwrap();
		2321	write_blog(&src, "");
		2322	std::fs::write(
		2323	src.join("blog/new.org"),
		2324	"#+TITLE: Newer Post\n#+DATE: [2025-06-30 Mon 09:15:00]\n\nBody with emphasis.\n",
		2325	)
		2326	.unwrap();
		2327	std::fs::write(
		2328	src.join("templates/feed.xml"),
		2329	"<rss>{% for p in pages %}<item><body>{{ p.content }}</body></item>{% endfor %}</rss>",
		2330	)
		2331	.unwrap();
		2332	std::fs::write(
		2333	src.join("org-ssg.toml"),
		2334	"[[collections]]\nsource = \"blog\"\noutput = \"feed.xml\"\n\
		2335	template = \"feed.xml\"\ntitle = \"Feed\"\ninclude_content = true\n",
		2336	)
		2337	.unwrap();
		2338	let out = root.join("out");
		2339	build(&src, &out);
		2340
		2341	let feed = page(&out, "feed.xml");
		2342	assert!(
		2343	feed.contains("<strong>emphasis</strong>"),
		2344	"the rendered body reaches the template, escaped as XML text:\n{feed}"
		2345	);
		2346
		2347	// And it stays current: a body edit must reach a feed that embeds bodies, even when
		2348	// no metadata moved.
		2349	std::fs::write(
		2350	src.join("blog/new.org"),
		2351	"#+TITLE: Newer Post\n#+DATE: [2025-06-30 Mon 09:15:00]\n\nBody with emphasis.\n\nA second paragraph.\n",
		2352	)
		2353	.unwrap();
		2354	build(&src, &out);
		2355	assert!(
		2356	page(&out, "feed.xml").contains("A second paragraph."),
		2357	"the feed followed the edit:\n{}",
		2358	page(&out, "feed.xml")
		2359	);
		2360	}
		2361
		2362	/// Bodies cost a render each, so a listing that does not ask for them must not pay — and
		2363	/// must not carry them into the template either.
		2364	#[test]
		2365	fn entries_carry_no_content_unless_asked() {
		2366	let root = tmpdir("nocontent");
		2367	let src = root.join("src");
		2368	std::fs::create_dir_all(&src).unwrap();
		2369	write_blog(&src, "");
		2370	std::fs::write(
		2371	src.join("templates/list.html"),
		2372	"<html><body>{% for p in pages %}<li>{{ p.content is none }}</li>{% endfor %}</body></html>",
		2373	)
		2374	.unwrap();
		2375	let out = root.join("out");
		2376	build(&src, &out);
		2377
		2378	let html = page(&out, "blog/index.html");
		2379	assert!(!html.contains("false"), "no entry carries a body:\n{html}");
		2380	}

Commit 768e668f7a

Commit `768e668f7a`