vowel 0.7.0-beta.0 → 0.7.1

package/plugins/markdown/index.js

@@ -13,11 +13,11 @@ import { gfmTable } from 'micromark-extension-gfm-table'
 import { gfmTableFromMarkdown } from 'mdast-util-gfm-table'
 import { normalizeHeadingLevels } from './metadata.js'
 import { readFileSync } from "fs"
-import { createHashtagPage, toTitleCase, listPages } from "./../../utils.js"
-import { toHast } from 'mdast-util-to-hast'
+import { createHashtagPage, labelFromName, showPages } from "./../../utils.js"
+import { toHast, defaultHandlers } from 'mdast-util-to-hast'
 import { toString as hastToString } from 'hast-util-to-string'
 import getMetadata, { reservedProperties } from "./metadata.js"
-import { isSecretPath } from "./../../secretPaths.js"
+import { isSecretPath, secretRouter, displayPath } from "./../../secretPaths.js"
 import { collectLinks } from "./links.js"
 import { readWalk } from "./readRules.js"
 import { h } from "hastscript"
@@ -68,7 +68,22 @@ function readFile(source, { api, config }) {
   }
 
 
-  if (metadata.fm_published === false) return
+  // `status` (frontmatter.js). A draft is not a page at all.
+  const status = metadata.fm_status ?? "published"
+  if (status === "draft") return
+
+  // A deleted page is not written, and carries nothing a listing, a tag
+  // page, a backlink or a wikilink could find it by. It exists only so
+  // `atproto-publish` can delete the record it used to have: its
+  // lexicon, and the url its record key is derived from (rkey.js).
+  if (status === "deleted") {
+    const kept = {
+      fm_status: status,
+      prettyURL: metadata.prettyURL,
+      ...("fm_atproto_lexicon" in metadata ? { fm_atproto_lexicon: metadata.fm_atproto_lexicon } : {})
+    }
+    return { data: "", write: false, metadata: kept }
+  }
 
   // Secrecy is a property of the *path* now: a segment containing "##"
   // is hashed by the config-level router cascade, so the page is only
@@ -79,10 +94,14 @@ function readFile(source, { api, config }) {
   // This replaces `secret_key` frontmatter, which hashed one page at a
   // time, could not cover a folder, left a virtual target at the public
   // path, and had to be hidden from its own rendering.
-  if (isSecretPath(filePath)) {
+  // `status: hidden` is the same promise made on purpose: written, never
+  // listed. So is the site's 404 page, generated or the author's own: it
+  // is served for a missing url, and no listing, sitemap, feed or
+  // AT Protocol record should name it.
+  if (isSecretPath(filePath) || status === "hidden" || filePath === "404.md") {
     metadata.hidden = true
-    metadata.local_menu_item ??= false
-    metadata.global_menu_item ??= false
+    metadata.local_nav_item ??= false
+    metadata.global_nav_item ??= false
     metadata.sitemap_item ??= false
     metadata.rss_item ??= false
   }
@@ -113,6 +132,13 @@ function readFile(source, { api, config }) {
 
 
   const hast = toHast(mdast, {
+    // A table in a <figure>: the figure scrolls sideways when the table
+    // is too wide, so the table itself can be a real table at full width
+    // (a table that scrolls has to be display: block, which sizes its
+    // columns to their content), and a caption has somewhere to go.
+    handlers: {
+      table: (state, node) => h("figure", [defaultHandlers.table(state, node)])
+    },
     // `state.all(node)` converts the children to hast; handing over
     // `node.children` gives the HTML compiler raw *mdast* instead. Plain
     // text survives that by coincidence - mdast and hast spell a text
@@ -191,7 +217,7 @@ function withDeclaredTypes(metadata) {
  * label inferred from its own filename - and its first paragraph became
  * the description. The site's name is `name:` (read as `fm_name`); a
  * `title:` here is an old spelling and is warned about, since a page
- * has a title and a site has a name. `tagline:` is warned about too: it
+ * has a title and a site has a name. `slogan:` is warned about too: it
  * is a page's, and the homepage's is the one a site shows on its front
  * door. `markdown` is the source, which the settings panel edits.
  * @param {Record<string, any>} metadata
@@ -202,8 +228,8 @@ function settingsContribution(metadata, filePath, log) {
   if (metadata.fm_title !== undefined && metadata.fm_name === undefined) {
     log?.("warn", `${filePath}: \`title:\` in a settings file does nothing - the site's name is \`name:\``)
   }
-  if (metadata.fm_tagline !== undefined) {
-    log?.("warn", `${filePath}: \`tagline:\` in a settings file does nothing - a tagline belongs to a page, e.g. home.md`)
+  if (metadata.fm_slogan !== undefined) {
+    log?.("warn", `${filePath}: \`slogan:\` in a settings file does nothing - a slogan belongs to a page, e.g. home.md`)
   }
   const declared = Object.entries(metadata)
     .filter(([key]) => key.startsWith("fm_") || reservedProperties.includes(key))
@@ -275,10 +301,12 @@ function createStubs({ api }) {
   ]
   const taken = new Set(named.map(stub => stub.path))
 
-  // A section index per folder with a listed page (see folderIndexes) -
-  // except where a stub above already is that page: `tags.md` is the
-  // tags folder's index.
-  return [...named, ...folderIndexes(api).filter(stub => !taken.has(stub.path))]
+  // A section index per folder with a listed page (see folderIndexes),
+  // and per secret folder with a page (secretFolderIndexes) - except
+  // where a stub above already is that page: `tags.md` is the tags
+  // folder's index.
+  const indexes = [...folderIndexes(api), ...secretFolderIndexes(api)]
+  return [...named, ...indexes.filter(stub => !taken.has(stub.path))]
 }
 
 /**
@@ -289,10 +317,13 @@ function createStubs({ api }) {
  * find it with no change.
  *
  * Derived from the targets, since there is no api.folders(): a folder
- * counts when a page *listPages would show* lives in it or below it.
- * An empty folder, an asset-only folder and a secret folder (every page
- * hidden) get no index, and a folder whose last page goes loses its
- * index on that pass - the stub is simply no longer declared.
+ * counts when a page *a listing would show* lives in it or below it -
+ * a page without a file (`html_file: false`) too, since the index is
+ * where its card is.
+ * An empty folder and an asset-only folder get no index, and a folder
+ * whose last page goes loses its index on that pass - the stub is simply
+ * no longer declared. A secret folder's pages are all hidden, so none
+ * counts here; secretFolderIndexes gives those folders theirs.
  *
  * An author's own `blog.md` beside `blog/` shadows the stub by path,
  * votive's ordinary rule; the stub stands down when `<folder>.html`
@@ -304,7 +335,7 @@ function createStubs({ api }) {
  * @param {any} api - the enumerator's untracked api
  */
 function folderIndexes(api) {
-  const pages = listPages(api, { folder: "", recursive: true })
+  const pages = showPages(api, { folder: "", recursive: true })
     .filter(page => page.source && page.dir)
 
   const folders = new Set()
@@ -323,6 +354,50 @@ function folderIndexes(api) {
   })
 }
 
+/**
+ * One index per secret folder (`members##salt/`) with a written page,
+ * and per folder below one. Per Sam: a secret folder should get its
+ * index like any other, and without one its breadcrumb had nothing to
+ * link to.
+ *
+ * Built in *source* terms, because a secret folder's published name is
+ * a hash. The stub is `members##salt.md`, which routing hashes to
+ * `<hash>.html` beside the folder's `<hash>/`, the way `blog.md` sits
+ * beside `blog/` - so the breadcrumb's `<folder>.html` lookup finds it.
+ * Its listing is a relative glob, the only kind that sees secret pages,
+ * and its title is the folder's name without the salt (expandStubs). As
+ * a page under a secret segment it is hidden itself.
+ *
+ * Folders *above* the secret segment get nothing from a secret page:
+ * their index would list none of it. A `status: hidden` page doesn't
+ * count. An author's own `members##salt.md` shadows the stub by path.
+ * @param {any} api - the enumerator's untracked api
+ */
+function secretFolderIndexes(api) {
+  const pages = api.targets({ folder: "", recursive: true, query: { hidden: true } })
+    .filter(page => page.write !== false
+      && page.extension === ".html"
+      && typeof page.source === "string"
+      && isSecretPath(page.source)
+      && page.metadata.fm_status !== "hidden")
+
+  const folders = new Set(pages.flatMap(page => {
+    const segments = page.source.split(path.sep).slice(0, -1)
+    const first = segments.findIndex(segment => isSecretPath(segment))
+    if (first === -1) return []
+    return segments.slice(first).map((_, offset) => segments.slice(0, first + offset + 1).join(path.sep))
+  }))
+
+  return [...folders].sort().flatMap(folder => {
+    const stubPath = `${folder}.md`
+    // vowel's router (config.js): secret segments hashed, then lowercased.
+    const routed = secretRouter(stubPath).toLowerCase().replace(/\.md$/, ".html")
+    const indexTarget = api.target(routed.split("/").join(path.sep))
+    const ours = !indexTarget || indexTarget.source === stubPath
+    return ours ? [{ path: stubPath, params: { folder, secret: true } }] : []
+  })
+}
+
 /**
  * Produces a declared stub's markdown, on demand.
  *
@@ -353,13 +428,23 @@ function expandStubs({ path: sourcePath, params }) {
     return { text: createHashtagPage(params.tag) }
   }
 
+  if (params?.secret) {
+    // A secret folder's index: titled by its name without the salt, and
+    // listed by a relative glob, resolved against this stub's own source
+    // path - the folder beside it - which is how a listing sees the
+    // secret pages a published-path glob never does.
+    const name = displayPath(params.folder).split(path.sep).at(-1)
+    const own = params.folder.split(path.sep).at(-1)
+    return { text: `# ${labelFromName(name)}\n\n./${own}/*` }
+  }
+
   if (params?.folder !== undefined) {
     // The folder's name as its title, and a listing of the folder - not
     // recursive: a nested section has an index of its own, and that
     // index is what appears here.
     const name = params.folder.split(path.sep).at(-1)
     const url = "/" + params.folder.split(path.sep).join("/")
-    return { text: `# ${toTitleCase(name)}\n\n${url}/*` }
+    return { text: `# ${labelFromName(name)}\n\n${url}/*` }
   }
 
   return null

package/plugins/markdown/metadata.js

@@ -1,8 +1,9 @@
 import { toString as mdastToString } from 'mdast-util-to-string'
 import extractDate, { dateSpan } from "./../../extractDate.js"
-import { testURL, toTitleCase } from "./../../utils.js"
+import { testURL, labelFromName } from "./../../utils.js"
 import path from "node:path"
 import { displayPath } from "../../secretPaths.js"
+import pathDate from "../../pathDate.js"
 import { coerce, parseFrontmatter, toISODate } from "./frontmatter.js"
 
 
@@ -35,12 +36,11 @@ export const reservedProperties = [
   "rss_item",
   "sitemap_item",
   "html_file",
-  "global_menu_item",
-  "local_menu_item",
+  "global_nav_item",
+  "local_nav_item",
   "theme",
   "logo",
-  "wordmark",
-  "breadcrumb"
+  "wordmark"
 ]
 
 /**
@@ -72,10 +72,10 @@ export function normalizeHeadingLevels(tree) {
 }
 
 /**
- * Marks a recognized date in place so it renders as <time> without moving
- * out of the content. The editor reads the element's text back, so the
- * author's own wording survives the round trip and the markup is simply
- * re-inferred on the next build.
+ * Marks a recognized date so it renders as <time>, keeping the author's
+ * wording. The editor reads the element's text back, so that wording
+ * survives the round trip and the markup is simply re-inferred on the
+ * next build.
  * @param {object} paragraph
  * @param {Date} date
  */
@@ -88,10 +88,16 @@ function markAsTime(paragraph, date) {
 }
 
 /**
- * Recognizable data that may precede the content. Each block is recorded
- * where the author placed it and never relocated - only the title is
- * hoisted (see findTitleNode). Adding another inferred property later (an
- * ISBN, say) means adding a branch here, not new plumbing.
+ * Recognizable data that may precede the content. A block is data only
+ * when the property it would fill is still empty: a date line on a page
+ * whose frontmatter has a `date:`, or a second date line, is content,
+ * and the scan stops there (per Sam). Returns what the block is: "date"
+ * or "image" for natural metadata, which the html plugin lifts out of
+ * the content and renders with the page's metadata (the source is never
+ * changed); "skip" for a line that is neither metadata nor content (a
+ * listing, a bare url); false for content. Adding another inferred
+ * property later (an ISBN, say) means adding a branch here, not new
+ * plumbing.
  *
  * @param {object} block
  * @param {object} metadata
@@ -103,10 +109,13 @@ function recognizeData(block, metadata) {
 
   const [child] = block.children
 
+  const imageFilled = Boolean(metadata.fm_image || metadata.inferred_image)
+
   if (child.type === "image") {
+    if (imageFilled) return false
     metadata.inferred_image = child.url
     metadata.inferred_alt_text = child.alt
-    return true
+    return "image"
   }
 
   const text = mdastToString(block)
@@ -116,16 +125,17 @@ function recognizeData(block, metadata) {
   // must not become the page's description, which is what a section
   // index's own listing line was doing. Same test as writeRules'
   // directive rule.
-  if (child.type === "text" && /^(\/|\.\.?\/)\S*$/.test(text.trim())) return true
+  if (child.type === "text" && /^(\/|\.\.?\/)\S*$/.test(text.trim())) return "skip"
 
   if (testURL(text)) {
     const url = new URL(text)
     if (text.match(/\.(jpeg|jpg|png)$/)) {
+      if (imageFilled) return false
       metadata.inferred_image = url
     } else {
       metadata.inferred_link = url
     }
-    return true
+    return "skip"
   }
 
   // A date is a property of the page only when the author wrote it as
@@ -144,12 +154,28 @@ function recognizeData(block, metadata) {
 
   const date = extractDate(text)
   if (!date) return false
+  if (metadata.fm_date || metadata.inferred_date) return false
 
   // Stored as ISO, like a frontmatter date (frontmatter.js, toISODate):
   // one format in the column, which sorts lexically.
   metadata.inferred_date = toISODate(date)
   markAsTime(block, date)
-  return true
+  return "date"
+}
+
+/**
+ * Marks a block as natural metadata - written in the text, not the
+ * frontmatter - for the html plugin to lift out of the content
+ * (`data-metadata`, which it removes): "date", "image", "description",
+ * or "end" for the rule that closed the description, which renders as
+ * nothing. A description is marked as one where it is rendered.
+ * @param {object} block
+ * @param {"date" | "image" | "description" | "end"} kind
+ */
+function markAsNatural(block, kind) {
+  const itemprop = kind === "description" ? { itemprop: "description" } : {}
+  const hProperties = { ...block.data?.hProperties, ...itemprop, dataMetadata: kind }
+  block.data = { ...block.data, hProperties }
 }
 
 /**
@@ -201,7 +227,7 @@ function getMetadata(tree, filePath, targetPath, report = () => {}) {
 
   const titleNode = findTitleNode(tree)
   if (titleNode) {
-    metadata.inferred_title = mdastToString(titleNode) || toTitleCase(path.parse(filePath).name)
+    metadata.inferred_title = mdastToString(titleNode) || labelFromName(path.parse(filePath).name)
   }
 
   // Everything up to the first block that is not recognizable data is
@@ -209,9 +235,27 @@ function getMetadata(tree, filePath, targetPath, report = () => {}) {
   // supplies the description.
   const blocks = tree.children.filter(child => child.type !== "yaml" && child !== titleNode)
 
-  for (const block of blocks) {
+  for (const [index, block] of blocks.entries()) {
     const recognized = recognizeData(block, metadata)
-    if (recognized) continue
+    if (recognized === "skip") continue
+    if (recognized) {
+      markAsNatural(block, recognized)
+      continue
+    }
+
+    // One paragraph and then a rule: the author ended their metadata
+    // with the rule, so the paragraph *is* the description - stated,
+    // not guessed, so it outranks a slogan. With a `description:` in the
+    // frontmatter it is an ordinary paragraph, and the rule an ordinary
+    // rule. (`text` then `---` on the next line is a heading in
+    // markdown, not a paragraph and a rule; it takes a blank line.)
+    const next = blocks[index + 1]
+    if (!metadata.fm_description && block.type === "paragraph" && next?.type === "thematicBreak") {
+      metadata.declared_description = mdastToString(block)
+      markAsNatural(block, "description")
+      markAsNatural(next, "end")
+      break
+    }
 
     if (!metadata.fm_description) metadata.inferred_description = mdastToString(block)
     break
@@ -229,7 +273,14 @@ function getMetadata(tree, filePath, targetPath, report = () => {}) {
   // sees, so it is the one place the salt has to be stripped.
   const pathInfo = path.parse(displayPath(filePath))
 
-  metadata.inferred_label = toTitleCase(pathInfo.name)
+  // A date the author wrote wins; failing that, the one the path spells
+  // (`journal/2024/april/1.md`).
+  if (!metadata.fm_date && !metadata.inferred_date) {
+    const date = pathDate(displayPath(filePath))
+    if (date) metadata.inferred_date = toISODate(date)
+  }
+
+  metadata.inferred_label = labelFromName(pathInfo.name)
 
   // What a [[wikilink]] matches, the way Obsidian matches: the filename
   // without its extension, case-insensitively, plus any `aliases:` the
@@ -283,7 +334,8 @@ function selectMetadata(metadata) {
 
   const description =
     metadata.fm_description
-    || metadata.fm_tagline
+    || metadata.declared_description
+    || metadata.fm_slogan
     || metadata.inferred_description
 
   if (description) {

package/plugins/markdown/typography.js

@@ -9,7 +9,7 @@
 // the document for live preview, so preview and build cannot disagree.
 //
 // No bundled fonts, and no font setting: a family is CSS - the author
-// sets `--font-sans-brand` (and the @font-face behind it) in their own
+// sets `--fontfamily-sans-brand` (and the @font-face behind it) in their own
 // stylesheet, where the sheet's stacks put a system fallback after it.
 // Fonts by url is tasks/2-in-progress/load-fonts.md. Free of node
 // builtins.
@@ -20,7 +20,7 @@
  * @property {string} variable - the custom property in TypographyStyles.css
  * @property {string} label
  * @property {string} [hint]
- * @property {"x" | "ch" | ""} unit - "x" is a multiple of --font-size-root
+ * @property {"x" | "ch" | ""} unit - "x" is a multiple of --fontsize-root
  * @property {number} min
  * @property {number} max
  * @property {number} step
@@ -29,14 +29,14 @@
 
 /** @type {TypographySetting[]} */
 export const rampSettings = [
-  { key: "heading-size", variable: "--font-size-delta", label: "Heading size", hint: "How much larger h1 is than body text", unit: "x", min: 0.25, max: 4, step: 0.05, default: 2 },
-  { key: "heading-size-decay", variable: "--font-size-decay", label: "Size decay", hint: "Higher makes subheadings smaller", unit: "", min: 0.5, max: 6, step: 0.1, default: 3 },
-  { key: "h1-letter-spacing", variable: "--letter-spacing-h1", label: "h1 letter spacing", unit: "ch", min: -0.1, max: 0.1, step: 0.005, default: -0.01 },
-  { key: "h6-letter-spacing", variable: "--letter-spacing-h6", label: "h6 letter spacing", unit: "ch", min: -0.1, max: 0.1, step: 0.005, default: 0 },
-  { key: "letter-spacing-decay", variable: "--letter-spacing-decay", label: "Spacing decay", unit: "", min: 0.5, max: 6, step: 0.1, default: 2 },
-  { key: "h1-weight", variable: "--font-weight-h1", label: "h1 weight", unit: "", min: 100, max: 900, step: 10, default: 800 },
-  { key: "h6-weight", variable: "--font-weight-h6", label: "h6 weight", unit: "", min: 100, max: 900, step: 10, default: 600 },
-  { key: "weight-decay", variable: "--font-weight-decay", label: "Weight decay", unit: "", min: 0.5, max: 6, step: 0.1, default: 2 }
+  { key: "heading-size", variable: "--fontsize-delta", label: "Heading size", hint: "How much larger h1 is than body text", unit: "x", min: 0.25, max: 4, step: 0.05, default: 2 },
+  { key: "heading-size-decay", variable: "--fontsize-decay", label: "Size decay", hint: "Higher makes subheadings smaller", unit: "", min: 0.5, max: 6, step: 0.1, default: 3 },
+  { key: "h1-letter-spacing", variable: "--letterspacing-h1", label: "h1 letter spacing", unit: "ch", min: -0.1, max: 0.1, step: 0.005, default: -0.01 },
+  { key: "h6-letter-spacing", variable: "--letterspacing-h6", label: "h6 letter spacing", unit: "ch", min: -0.1, max: 0.1, step: 0.005, default: 0 },
+  { key: "letter-spacing-decay", variable: "--letterspacing-decay", label: "Spacing decay", unit: "", min: 0.5, max: 6, step: 0.1, default: 2 },
+  { key: "h1-weight", variable: "--fontweight-h1", label: "h1 weight", unit: "", min: 100, max: 900, step: 10, default: 800 },
+  { key: "h6-weight", variable: "--fontweight-h6", label: "h6 weight", unit: "", min: 100, max: 900, step: 10, default: 600 },
+  { key: "weight-decay", variable: "--fontweight-decay", label: "Weight decay", unit: "", min: 0.5, max: 6, step: 0.1, default: 2 }
 ]
 
 /**
@@ -57,7 +57,7 @@ function themeSettings(theme) {
 function rampValue(setting, value) {
   const clamped = Math.min(setting.max, Math.max(setting.min, value))
   const number = String(Number(clamped.toFixed(4)))
-  if (setting.unit === "x") return `calc(${number} * var(--font-size-root))`
+  if (setting.unit === "x") return `calc(${number} * var(--fontsize-root))`
   return `${number}${setting.unit}`
 }
 

package/plugins/secret-pages/index.js

@@ -0,0 +1,75 @@
+import { styleText } from "node:util"
+import { isSecretPath } from "../../secretPaths.js"
+
+/** @import * as Votive from "votive" */
+
+/**
+ * Where your secret pages are. A page under a `##` segment is published
+ * at a hashed url that nothing on the site links to, so the author needs
+ * another way to find it: the dev server prints each one, file and url,
+ * when it first sees it - every one at startup, then each new one (or a
+ * renamed one, whose url changed) as it appears.
+ *
+ * **Only the dev server.** `init()` turns this on with
+ * `config.announceSecretPages`; `deploy`, `publish` and a plain build
+ * never do. Those run in CI too, where logs are kept and can be public,
+ * and a logged url is exactly what the hash exists to keep private.
+ *
+ * It is a stub enumerator that declares no stubs: the one hook that runs
+ * on every pass and can list pages. It lists only the hidden ones - a
+ * secret page is always hidden (markdown/index.js) - so a pass costs an
+ * indexed query, not a listing of the site.
+ */
+
+/**
+ * What has been printed, per site: the config votive hands every pass
+ * is the same object for the life of a site, so a reopened project (the
+ * desktop app) prints its pages again.
+ * @type {WeakMap<object, Set<string>>}
+ */
+const announced = new WeakMap()
+
+/**
+ * @param {string | undefined} domain
+ * @param {string} prettyURL
+ */
+function pageURL(domain, prettyURL) {
+  if (typeof domain !== "string" || !domain) return prettyURL
+  const base = domain.startsWith("http") ? domain : `https://${domain}`
+  return new URL(prettyURL, base).href
+}
+
+/** @type {Votive.ProcessorStubs} */
+function createStubs({ api, settings, config }) {
+  if (!config.announceSecretPages || config.logging === "silent") return []
+
+  const seen = announced.get(config) ?? new Set()
+  announced.set(config, seen)
+
+  const hidden = api.targets({ folder: "", recursive: true, query: { hidden: true } })
+  const pages = hidden.filter(target => (
+    target.extension === ".html"
+    && target.write !== false
+    && typeof target.source === "string"
+    && isSecretPath(target.source)
+  ))
+  const domain = settings.lastNonNull("fm_domain")
+  const fresh = pages
+    .map(page => ({ source: page.source, url: pageURL(domain, page.metadata.prettyURL) }))
+    .filter(({ source, url }) => !seen.has(`${source} ${url}`))
+    .sort((a, b) => a.source < b.source ? -1 : a.source > b.source ? 1 : 0)
+
+  for (const { source, url } of fresh) {
+    seen.add(`${source} ${url}`)
+    console.info(`${styleText("dim", "secret:")} ${styleText("yellow", source)} ${styleText("dim", "→")} ${styleText("cyan", url)}`)
+  }
+  return []
+}
+
+/** @type {Votive.VotivePlugin} */
+const vowelSecretPagesPlugin = {
+  name: "vowel-secret-pages",
+  processors: [{ createStubs }]
+}
+
+export default vowelSecretPagesPlugin

package/plugins/styles/index.js

@@ -4,7 +4,7 @@ import { styleText } from "node:util"
 import { transform } from "lightningcss"
 import { hash } from "node:crypto"
 import { resolveTheme, themeStylesheets, themeKey } from "./theme.js"
-import { themeColorSchemeCSS } from "../markdown/colorScheme.js"
+import { themeColorSchemeCSS, colorParams } from "../markdown/colorScheme.js"
 import { typographyCSS } from "../markdown/typography.js"
 
 /** @import * as Votive from "votive" */
@@ -54,7 +54,7 @@ function createStubs({ api, settings }) {
     return themeStylesheets(theme, rootTheme).map(sheet => {
       // Generated sheets carry the part of the theme they are generated
       // from, so they re-expand exactly when that part changes.
-      if (sheet.startsWith("colors")) return { path: sheet, params: { colors: config.colors ?? null } }
+      if (sheet.startsWith("colors")) return { path: sheet, params: colorParams(config) }
       if (sheet.startsWith("type")) return { path: sheet, params: { theme: config } }
       return { path: sheet }
     })
@@ -80,8 +80,8 @@ function expandStubs({ path: sourcePath, params }) {
     // Reports and falls back rather than throwing: a site with unusable
     // colours should lose its palette, not its build.
     return {
-      text: themeColorSchemeCSS(params?.colors, error => (
-        console.warn(`${styleText("dim", "build: ")}${styleText("yellow", `ignoring theme.colors - ${error.message}`)}`)
+      text: themeColorSchemeCSS(params ?? {}, error => (
+        console.warn(`${styleText("dim", "build: ")}${styleText("yellow", error.message)}`)
       ))
     }
   }

package/plugins/xml/entryContent.js

@@ -70,17 +70,7 @@ function isContentSection(node) {
  * @returns {string} the body as HTML, or "" when there is no content
  */
 export function entryContent(html, domain) {
-  if (!html) return ""
-
-  const tree = fromHtml(html, { fragment: false })
-
-  /** @type {import("hast").Element | undefined} */
-  let content
-  visit(tree, isContentSection, (node) => {
-    content = node
-    return false
-  })
-
+  const content = contentSection(html)
   if (!content) return ""
 
   visit(content, "element", (node) => {
@@ -100,4 +90,25 @@ export function entryContent(html, domain) {
   return toHtml({ type: "root", children: content.children })
 }
 
+/**
+ * The rendered page's `<section id=content>` - the post body - as a hast
+ * element, untouched, or undefined when the page has none. Shared by the
+ * feed and by atproto-publish, which both want the post and not the
+ * page around it.
+ * @param {string | null | undefined} html - the page's rendered output
+ * @returns {import("hast").Element | undefined}
+ */
+export function contentSection(html) {
+  if (!html) return undefined
+  const tree = fromHtml(html, { fragment: false })
+
+  /** @type {import("hast").Element | undefined} */
+  let content
+  visit(tree, isContentSection, (node) => {
+    content = node
+    return false
+  })
+  return content
+}
+
 export default entryContent

package/plugins/xml/index.js

@@ -1,5 +1,5 @@
 import xml from "xml"
-import { listPages } from "./../../utils.js"
+import { showPages, isPageWithoutFile } from "./../../utils.js"
 import { entryContent } from "./entryContent.js"
 
 /** @import * as Votive from "votive" */
@@ -78,7 +78,8 @@ const processor = {
             }
           },
         })
-        .filter(a => a.extension === ".html" && a.path)
+        // A virtual page - `html_file: false`, `status: deleted` - has no url.
+        .filter(a => a.extension === ".html" && a.path && a.write !== false)
 
       // No {delete: true} any more: this target exists only because the
       // enumerator declared it, and it does that only when a domain is
@@ -133,7 +134,10 @@ const processor = {
       // the entries kept read it. `feed_limit` in settings.md raises or
       // lowers it.
       const limit = Number(settings.lastNonNull("fm_feed_limit")) || DEFAULT_FEED_LIMIT
-      const pages = listPages(api, {
+      // A page with no file (`html_file: false`) is an entry too, with
+      // its body and no <link>: Atom needs an <id> and content, not a
+      // link, which is what makes a feed-only post possible.
+      const pages = showPages(api, {
         query: {
           "!": {
             rss_item: false
@@ -193,21 +197,25 @@ const processor = {
 
       feed.push(
         ...pages.map((page) => {
+          // The url the page has, or would have: an Atom <id> is an
+          // identifier, so a page without a file keeps the one it would
+          // have, and keeps it if it gets a file later.
           const url = (new URL(page.path, domain)).href
+          const link = isPageWithoutFile(page) ? [] : [{
+            link: {
+              _attr: {
+                rel: 'alternate',
+                href: url
+              }
+            }
+          }]
 
           /** @type {object[]} */
           const entry = [
             {
               title: page.metadata.title
             },
-            {
-              link: {
-                _attr: {
-                  rel: 'alternate',
-                  href: url
-                }
-              }
-            },
+            ...link,
             { id: url },
             { updated: page.metadata.date }
           ];