@heroiclands/package-build 22.15.0 → 22.16.0

package/engine/content-html.mjs

@@ -15,7 +15,7 @@
  * Raw HTML in a note's prose, reported.
  *
  * **A note is markdown.** What markdown cannot say, a note does not say — it
- * gets a construct every surface can render, the way `:icon-…:` replaces a
+ * gets a construct every surface can render, the way `:icon …:` replaces a
  * pasted glyph.
  *
  * ## There is no route from `<p>` to a book

package/engine/content-icons.mjs

@@ -12,61 +12,22 @@
  */
 
 /**
- * Naming an interface icon in a note, without drawing it there.
- *
- * The user guide describes Foundry's interface, and it did so by pasting
- * Unicode lookalikes of the icons the sheets actually draw: `☆` for the improve
- * flag, `✎` for the formula editor, `◆` in the success-value table, `★★★` for
- * mastery. The system renders every one of those with **Font Awesome** — a
- * `fa-regular fa-star`, a `fa-solid fa-pen-to-square` — so the note and the
- * screen it describes were drawing different pictures, and drifting apart with
- * every sheet change.
- *
- * They are also the worst characters in the corpus to typeset. Of the eight
- * book faces probed, **none** carries `✕ ✗ ✎ ☆ ⚗ ➕`; in a Libertinus
- * setting `✕` resolves to macOS LastResort, which draws a tofu box.
- *
- * **Neither obvious fix works.** Keeping the dingbats pins the book to some
- * icon-capable font forever, which is the coupling this exists to remove.
- * Pasting Font Awesome's own codepoints is worse: they live in the Private Use
- * Area, which is unassigned by definition, so they break search, copy-paste and
- * screen readers, and no charset check can validate them.
- *
- * So a note **names** an icon and never contains one. `:icon-star-outline:` is
- * ASCII, it is greppable, it survives a charset check, and it degrades to
- * visible literal text on any surface that has not been taught to render it —
- * which is the failure mode you want, because you can see it.
- *
- * **Why a registry rather than the Font Awesome classes.** Three surfaces need
- * three different artefacts from one name: the journals and the website want
- * `<i class="fa-solid fa-star">`, and the PDF wants a font file and a glyph.
- * Only a mapping serves both. It also means a Font Awesome major version that
- * renames an icon — `fa-trash-o` became `fa-trash-can` — costs one line here
- * rather than a sweep of the corpus, and it lets an unknown name be *reported*
- * instead of passing silently through as literal text.
- *
- * **The codepoint is deliberately not here.** A renderer that embeds Font
- * Awesome has to read the font to subset it, and the font's own `cmap` is the
- * only trustworthy source for which glyph a name resolves to. Writing the
- * codepoints out by hand would be a second copy of that table, wrong the first
- * time Font Awesome renumbers anything, and wrong silently. This module states
- * the style and the name; the renderer resolves them against the file it ships.
- *
- * **Licence.** Font Awesome Free's icons are CC BY 4.0 and its fonts SIL OFL
- * 1.1, so a distributed PDF may embed the subset it uses. Attribution belongs
- * in the book's colophon, not in every note.
- *
- * **Every finding here is a `warning`**, so nothing this module says can fail a
- * build — `reportFindings` fails on an error and not on a warning. An
- * undeclared name renders as its own literal text, which is visible on the page
- * and wrong in a way a reader will notice; that deserves to be reported and
- * does not deserve to stop a build that is otherwise correct.
+ * Resolve named inline font glyphs from a package's icon registry.
+ *
+ * A note writes `:icon warning:` or `:icon warning:{size=2x}`. Registry keys
+ * use lowercase letters, digits and hyphens. The package supplies the font,
+ * stylesheet, glyph name and accessible label. Unknown names remain literal
+ * and produce a warning; malformed syntax and attributes produce errors.
+ *
+ * The registry stores glyph names rather than font codepoints. Print reads the
+ * font file's character map, while HTML uses the declared style classes.
  *
  * @module
  */
 
 import fs from "node:fs";
 import path from "node:path";
+import { parseExtensionAttributes } from "./extension-attributes.mjs";
 
 /**
  * A **family** is an icon font, and a consumer declares the ones it ships.
@@ -117,7 +78,7 @@ import path from "node:path";
  *
  * Empty rather than a starter set, because a starter set is a promise about
  * fonts this package does not ship. A tree with no `icons:` configured names no
- * icons, and `:icon-star:` in one of its notes renders as its own literal text
+ * icons, and `:icon star:` in one of its notes renders as its own literal text
  * and is reported — which is the visible failure, not a silent one.
  *
  * @type {IconRegistry}
@@ -203,22 +164,11 @@ export function parseIconAttributes(raw) {
     const problems = [];
     if (!raw || !raw.trim()) return { attrs, problems };
 
-    // Split on commas, not whitespace: `size: 2x` is one pair with a space in
-    // it, and the space after the colon is the whole point of the spelling.
-    for (const part of raw
-        .split(",")
-        .map((s) => s.trim())
-        .filter(Boolean)) {
-        const colon = part.indexOf(":");
-        if (colon === -1) {
-            problems.push(
-                `\`${part}\` is not a \`key: value\` attribute — an icon takes ` +
-                    `${Object.keys(ICON_ATTRIBUTES).join(", ")}`,
-            );
-            continue;
-        }
-        const key = part.slice(0, colon).trim();
-        const value = part.slice(colon + 1).trim();
+    const parsed = parseExtensionAttributes(raw);
+    problems.push(...parsed.problems);
+    if (parsed.id) problems.push("an icon does not accept an id");
+    if (parsed.classes.length) problems.push("an icon does not accept classes");
+    for (const [key, value] of Object.entries(parsed.values)) {
         const spec =
             Object.prototype.hasOwnProperty.call(ICON_ATTRIBUTES, key) ?
                 ICON_ATTRIBUTES[key]
@@ -232,7 +182,7 @@ export function parseIconAttributes(raw) {
         }
         if (!spec.values.includes(value)) {
             problems.push(
-                `\`${key}: ${value}\` is not one of ${spec.values.join(", ")} — ` +
+                `\`${key}=${value}\` is not one of ${spec.values.join(", ")} — ` +
                     `${key} says ${spec.describe}`,
             );
             continue;
@@ -245,25 +195,16 @@ export function parseIconAttributes(raw) {
 /**
  * The shape a note writes, and the one this module claims.
  *
- * The `icon-` prefix is what keeps it out of the way of an emoji shortcode: a
- * surface that also renders `:smile:` can tell the two apart without a lookup,
- * and a reader can tell what `:icon-star:` is without knowing this module
- * exists. Names are lowercase, digits and hyphens — the charset an address
- * segment already uses, so nothing new has to be explained.
- *
- * Not `:name[content]`. That is remark-directive syntax, and this toolchain
- * parses with markdown-it; a directive would render as its own literal text.
+ * The `icon` keyword distinguishes inline glyphs from asset Addresses and
+ * other colon-based shorthand. Names use lowercase letters, digits and
+ * hyphens, and each name resolves in the package's declared icon registry.
  *
- * An optional trailing brace carries **attributes**:
+ * An optional brace carries attributes, for example:
  *
- *     :icon-affiliation:{size: 2x}
+ *     :icon affiliation:{size=2x}
  *
- * `key: value` pairs, comma-separated, in the shape `markdown-it-attrs` and
- * remark-directive already use — so it is a convention a reader may recognise
- * rather than one this module invented. Attributes rather than a bare value
- * because `size` is merely the first one anybody needed: a fixed-width flag, a
- * rotation, a title override are the same shape of thing, and a syntax that
- * could only ever express size would have to be replaced to gain any of them.
+ * Attributes are whitespace-separated `key=value` pairs. The closed `size`
+ * values are declared in {@link ICON_SIZES}.
  *
  * One inline rule consumes the token **and** its brace, so there is no state in
  * which the icon resolves and the brace is left stranded on the page. An
@@ -271,12 +212,13 @@ export function parseIconAttributes(raw) {
  *
  * @type {RegExp}
  */
-export const ICON_PATTERN = /:icon-([a-z0-9]+(?:-[a-z0-9]+)*):(?:\{([^}]*)\})?/g;
+export const ICON_PATTERN = /:icon ([a-z0-9]+(?:-[a-z0-9]+)*):(?:\{([^}]*)\})?/g;
+const OBSOLETE_ICON_PATTERN = /:icon-([a-z0-9]+(?:-[a-z0-9]+)*):(?:\{([^}]*)\})?/g;
 
 /**
  * Look one name up.
  *
- * @param {string} name - The name written between the colons, without `icon-`.
+ * @param {string} name - The name written between the colons, without `icon `.
  * @param {IconRegistry} [registry] - The package's registry.
  * @returns {object|null} The entry, or `null` when the registry does not
  *   declare it.
@@ -355,17 +297,28 @@ export function iconsIn(text) {
  * Report every icon a tree names that its registry does not declare.
  *
  * The whole point of a registry is that a typo is answerable, so this is the
- * half that makes `:icon-stra:` a finding rather than three words of literal
+ * half that makes `:icon stra:` a finding rather than three words of literal
  * text nobody notices in a rendered page.
  *
  * @param {string} text - The file's contents.
  * @param {string} file - Path to report.
  * @param {IconRegistry} [registry] - The package's registry.
  * @returns {Array<{file: string, line: number, column: number,
- *   severity: "warning", message: string}>} The unknown names.
+ *   severity: "warning"|"error", message: string}>} The findings.
  */
 export function lintIcons(text, file, registry = EMPTY_ICON_REGISTRY) {
     const findings = [];
+    for (const match of text.matchAll(OBSOLETE_ICON_PATTERN)) {
+        const index = match.index ?? 0;
+        const before = text.slice(0, index);
+        findings.push({
+            file,
+            line: before.split("\n").length,
+            column: index - (before.lastIndexOf("\n") + 1) + 1,
+            severity: "error",
+            message: `\`${match[0]}\` needs the form \`:icon ${match[1]}:\``,
+        });
+    }
     for (const { name, index, raw, problems } of iconsIn(text)) {
         const before = text.slice(0, index);
         const line = before.split("\n").length;
@@ -380,7 +333,7 @@ export function lintIcons(text, file, registry = EMPTY_ICON_REGISTRY) {
                 ...at,
                 message:
                     `\`${raw}\` names an icon the registry does not declare` +
-                    (suggestion ? `; did you mean \`:icon-${suggestion}:\`?` : "") +
+                    (suggestion ? `; did you mean \`:icon ${suggestion}:\`?` : "") +
                     ` — an undeclared name renders as its own literal text`,
             });
             // The name is the bigger fault; reporting its attributes as well
@@ -392,7 +345,7 @@ export function lintIcons(text, file, registry = EMPTY_ICON_REGISTRY) {
         // and renders differently from what was asked for, which is the case
         // nobody notices without being told.
         for (const problem of problems) {
-            findings.push({ ...at, message: `\`${raw}\`: ${problem}` });
+            findings.push({ ...at, severity: "error", message: `\`${raw}\`: ${problem}` });
         }
     }
     return findings;
@@ -612,11 +565,11 @@ export function lintContentIcons(contentBase, { skipDirectories = [], registry }
 }
 
 /**
- * A markdown-it plugin rendering `:icon-name:` inline.
+ * A markdown-it plugin rendering `:icon name:` inline.
  *
  * An unknown name is left **exactly as written** rather than dropped. The name
  * is reported by {@link lintIcons}, and a rendered page that still shows
- * `:icon-stra:` is how the author finds it without reading a log.
+ * `:icon stra:` is how the author finds it without reading a log.
  *
  * **A function is accepted as well as a table**, and resolved per render. The
  * shared markdown-it instance is a module-level constant, so it is built before
@@ -645,7 +598,7 @@ export function iconPlugin(registry = EMPTY_ICON_REGISTRY) {
             if (state.src.charCodeAt(start) !== 0x3a /* : */) return false;
             // Anchored at the cursor, so the scan is O(token) rather than a
             // search of the remaining source at every colon in the paragraph.
-            const re = /^:icon-([a-z0-9]+(?:-[a-z0-9]+)*):(?:\{([^}]*)\})?/;
+            const re = /^:icon ([a-z0-9]+(?:-[a-z0-9]+)*):(?:\{([^}]*)\})?/;
             const m = re.exec(state.src.slice(start));
             if (!m) return false;
 

package/engine/content-images.mjs

@@ -16,15 +16,15 @@
  * no way to say. A directive in the curly-attribute convention Pandoc and
  * Kramdown use closes that:
  *
- *     ![Brànwâal Dôrgaar](images/beings/branwldrgr-portrait.webp){float: top-left}
+ *     ![Brànwâal Dôrgaar](images/beings/branwldrgr-portrait.webp){float=top-left}
  *     ![Map of Thalorna](images/map.webp){.full-width}
  *
  * ## Three closed vocabularies, and closed is the point
  *
  * **Width is a class**, and the ordinary width carries no marker at all — the
  * simple case needs no spelling. {@link IMAGE_CLASSES} holds the one class
- * there is. **Position is `float:`**, and {@link IMAGE_FLOATS} holds the five
- * values it takes. **Named size is `size:`**, and {@link IMAGE_SIZES} holds its
+ * there is. **Position is `float`**, and {@link IMAGE_FLOATS} holds the five
+ * values it takes. **Named size is `size`**, and {@link IMAGE_SIZES} holds its
  * values. The HTML surfaces receive a size class; the book receives a print
  * measure.
  *
@@ -77,6 +77,7 @@ import fs from "node:fs";
 import path from "node:path";
 
 import { matchAllOutsideCode } from "./code-fences.mjs";
+import { parseExtensionAttributes } from "./extension-attributes.mjs";
 import { positionInBody } from "./diagnostics.mjs";
 import { foundryAddressProblem, pathnameProblem, servesFoundry } from "./pathnames.mjs";
 
@@ -117,7 +118,7 @@ export const IMAGE_SIZES = Object.freeze([
 ]);
 
 /**
- * The `float:` positions an image may take, and where each puts it.
+ * The `float` positions an image may take, and where each puts it.
  *
  * `align` is the Typst alignment the float is placed at. **Print cannot wrap
  * text around an arbitrary shape**: a Typst float occupies the column measure,
@@ -235,7 +236,6 @@ export function parseImageDirective(raw) {
     /** @type {string[]} */
     const classes = [];
     let size = "auto";
-    let sizeSeen = false;
     let float = "";
     /** @type {string[]} */
     const problems = [];
@@ -245,75 +245,23 @@ export function parseImageDirective(raw) {
         .replace(/\}$/, "");
     if (!inner.trim()) return { classes, size, float, problems };
 
-    // Split on commas, not whitespace: `float: top-left` is one pair with a
-    // space in it, and the space after the colon is the spelling people write.
-    for (const part of inner
-        .split(",")
-        .map((s) => s.trim())
-        .filter(Boolean)) {
-        if (part.startsWith(".")) {
-            const name = part.slice(1);
-            if (!Object.prototype.hasOwnProperty.call(IMAGE_CLASSES, name)) {
-                problems.push(
-                    `\`.${name}\` is not a width an image has — the width there is ` +
-                        `is \`.${Object.keys(IMAGE_CLASSES).join("`, `.")}\`, and an image ` +
-                        "with no class at all is the ordinary width",
-                );
-                continue;
-            }
-            if (classes.includes(name)) {
-                problems.push(`\`.${name}\` is written twice, and an image has one width`);
-                continue;
-            }
-            classes.push(name);
-            continue;
-        }
-
-        const colon = part.indexOf(":");
-        if (colon === -1) {
-            problems.push(
-                `\`${part}\` is neither a width class nor \`size: <name>\` or ` +
-                    "`float: <position>` — an image states its width as a class and its position as `float:`, " +
-                    "and it states no dimensions at all",
-            );
-            continue;
-        }
-        const key = part.slice(0, colon).trim();
-        const value = part.slice(colon + 1).trim();
+    const parsed = parseExtensionAttributes(inner);
+    problems.push(...parsed.problems);
+    if (parsed.id) problems.push("an image does not accept an id");
+    for (const name of parsed.classes) {
+        if (!Object.hasOwn(IMAGE_CLASSES, name)) problems.push(`.${name} is not an image width`);
+        else classes.push(name);
+    }
+    for (const [key, value] of Object.entries(parsed.values)) {
         if (key === "size") {
-            if (!IMAGE_SIZES.includes(value)) {
-                problems.push(
-                    `\`size: ${value}\` is not a size — the ones there are: ${IMAGE_SIZES.join(", ")}`,
-                );
-                continue;
-            }
-            if (sizeSeen) {
-                problems.push("`size:` is written twice, and an image has one named size");
-                continue;
-            }
-            size = value;
-            sizeSeen = true;
-            continue;
-        }
-        if (key !== "float") {
-            problems.push(
-                `\`${key}\` is not an image attribute — use \`size\` or \`float\`, ` +
-                    "and width is a class rather than an attribute",
-            );
-            continue;
-        }
-        if (!Object.prototype.hasOwnProperty.call(IMAGE_FLOATS, value)) {
-            problems.push(
-                `\`float: ${value}\` is not a position — the ones there are: ` +
-                    `${Object.keys(IMAGE_FLOATS).join(", ")}`,
-            );
-            continue;
-        }
-        if (float) {
-            problems.push("`float:` is written twice, and an image sits in one place");
-            continue;
-        }
-        float = value;
+            if (!IMAGE_SIZES.includes(value))
+                problems.push(`size=${value} is not a named image size`);
+            else size = value;
+        } else if (key === "float") {
+            if (!Object.hasOwn(IMAGE_FLOATS, value))
+                problems.push(`float=${value} is not an image position`);
+            else float = value;
+        } else problems.push(`${key} is not an image attribute`);
     }
 
     if (classes.length > 1) {
@@ -666,7 +614,7 @@ export function renderImageFigures(body, resolveSrc = (src) => src) {
  * A markdown-it plugin that reads an image's directive and renders its figure.
  *
  * **A core rule, not an inline one.** markdown-it's own `image` rule consumes
- * `![alt](src)` and leaves `{float: top-left}` behind as text, and a rule
+ * `![alt](src)` and leaves `{float=top-left}` behind as text, and a rule
  * running before it would have to re-implement link parsing to find the brace.
  * Reading the token stream afterwards costs one pass and re-implements nothing.
  *

package/engine/content-index.mjs

@@ -33,8 +33,7 @@
  * one type is ordinary authoring. Any format that fixes a column set would turn
  * that authoring into a schema migration, so nothing here selects, flattens, or
  * renames — a reader addresses `sohl.body.weight.base` because that is what the
- * note says, which is also, not by accident, exactly what a `dataview` query
- * writes.
+ * note says, which a SQL query can address directly.
  *
  * **JSON Lines rather than a database.** The artifact has to survive its build
  * and be usable by anything — a person with `jq`, an editor, a CI check,
@@ -46,7 +45,7 @@
  * nested access — whereas a stored schema would forfeit the open shape.
  *
  * **Byte-stable, because it is meant to be rebuilt.** {@link emitContentIndex}
- * is reachable on its own (`content-build content-index`) and costs a
+ * is reachable on its own (`package-build content-index`) and costs a
  * frontmatter parse, not a build, so the honest expectation is that anyone
  * regenerates it whenever they want rather than treating it as precious. That
  * only holds if two runs over an unchanged tree produce an identical file, so
@@ -152,6 +151,7 @@ import { isDraftNote } from "./note-vocabulary.mjs";
 // a record is built, so the index carries it without the note being written to.
 import { applyComputedBeingAge, presentAmongFrontmatters } from "./being-age.mjs";
 import { reckoningContext } from "./reckoning-markers.mjs";
+import { resolvedDateFields } from "./note-dates.mjs";
 
 export {
     authoredFrontmatter,
@@ -441,6 +441,8 @@ function assertNoDerivedKeys(frontmatter, relPath, absPath, contentPackage) {
  * @param {number} [options.bodyLine] - The 1-based file line the body starts on.
  * @param {object} [options.manifest] - The package manifest, which the Foundry
  *   entries are derived against.
+ * @param {object} [options.addressContext] - Address resolution context.
+ * @param {object} [options.dateContext] - Calendar conversion context.
  * @returns {Record<string, any>} The record, keys sorted at every depth. A
  *   **stub** — a note with an empty body, on a type an empty body suppresses —
  *   carries `address` and `anchors` as `null`: it publishes no page, so it
@@ -461,6 +463,7 @@ export function buildIndexRecord({
     bodyLine,
     manifest,
     addressContext,
+    dateContext,
 }) {
     assertNoDerivedKeys(frontmatter, relPath, absPath, contentPackage);
 
@@ -494,11 +497,13 @@ export function buildIndexRecord({
     // its file is what the author edits and what every diagnostic names, and
     // its `id` is the identity every diagnostic and every table reads.
     const stub = isStubNote(frontmatter, body);
+    const resolvedDates = dateContext ? resolvedDateFields(frontmatter, dateContext) : {};
 
     return /** @type {Record<string, any>} */ (
         decodeIndexAddresses(
             {
                 ...frontmatter,
+                ...(Object.keys(resolvedDates).length ? { resolvedDates } : {}),
                 package: contentPackage,
                 address: stub ? null : address,
                 nameAscii: asciiName(frontmatter?.name?.full),
@@ -609,6 +614,7 @@ export function indexRecordsForNote({
     contentPackage,
     manifest,
     addressContext,
+    dateContext,
 }) {
     resolveNoteId(frontmatter, { pkg: contentPackage });
     const record = buildIndexRecord({
@@ -620,6 +626,7 @@ export function indexRecordsForNote({
         contentPackage,
         manifest,
         addressContext,
+        dateContext,
     });
     const records = [decodeIndexAddresses(record, addressContext ?? { package: contentPackage })];
     const address = noteAddress(frontmatter, contentPackage);
@@ -663,6 +670,7 @@ export function indexRecordsForNote({
  *   anyway.
  * @param {object} [options.manifest] - The package manifest, which the Foundry
  *   entries are derived against.
+ * @param {object} [options.addressContext] - Address resolution context.
  * @param {object[]} [options.problems] - Supplied by a **reader**: a note that
  *   cannot be recorded is pushed here as a diagnostic and skipped. Omitted, the
  *   note throws — the contract the emitter needs, since an index missing a note
@@ -710,6 +718,7 @@ export function collectContentIndex(
                     bodyLine,
                     manifest,
                     addressContext,
+                    dateContext: dates,
                 }),
             );
         } catch (err) {

package/engine/content-links.mjs

@@ -78,8 +78,8 @@ import { foundryAddressProblem, servesFoundry } from "./pathnames.mjs";
 import { hasDocEntry } from "./item-docs.mjs";
 import { ownDocumentSystem } from "./address.mjs";
 import { NOTE_SYSTEM } from "./systems.mjs";
+import { isGmNote } from "./note-vocabulary.mjs";
 import { loadPackConfig } from "./pack-config.mjs";
-import { searchableFrontmatter } from "./note-package.mjs";
 import {
     blockSystem,
     canonicalKey,
@@ -301,18 +301,8 @@ export function buildLinkIndex(
         foreign: foreign.index,
     };
 
-    /** The searchable universe a `dataview` table draws its rows from. */
-    const tableDocs = notes.map((n) => ({
-        // Package present for a `WHERE … package = "…"` clause, synthesised
-        // rather than authored — see {@link searchableFrontmatter}.
-        fm: searchableFrontmatter(n.fm, pkg),
-        path: n.rel,
-        tld: n.rel.split("/")[0],
-        folder: path.dirname(n.rel).split("/").pop(),
-    }));
-
     /**
-     * One note's body with its `dataview` and `sql` tables expanded.
+     * One note's body with its SQL tables expanded.
      *
      * The body every body-level check reads, so a link and an embed in one note
      * are found in the same text — a generated table is as free to carry either
@@ -323,12 +313,8 @@ export function buildLinkIndex(
      */
     function expandedBody(note) {
         const body = note.body;
-        if (!/^[ \t]*(?:`{3,}|~{3,})[ \t]*(?:dataview|sql)\b/im.test(body)) return body;
+        if (!/^[ \t]*(?:`{3,}|~{3,})[ \t]*sql\b/im.test(body)) return body;
         return expandContentTables(body, {
-            // Unfiltered: every note in the tree is this package's, so
-            // there is no other package's note to exclude.
-            docs: tableDocs,
-            linkable: (d) => Boolean(d.fm.shortcode),
             source: note.file,
             // A `sql` table's links are checked like an authored one's, so
             // its rows are prepared ahead of this walk — see
@@ -392,7 +378,7 @@ export function buildLinkIndex(
     }
 
     /**
-     * Every wikilink in a note body, with its `dataview` tables expanded.
+     * Every wikilink in a note body, with its SQL tables expanded.
      *
      * An `![[…]]` embed is not one: it names a file rather than a note, and
      * {@link module:engine/wikilink-syntax.WIKILINK} excludes it so that no
@@ -779,9 +765,8 @@ function readAddress(url, packages) {
  *
  * **Why the homepage needs its own audit at all.** Every other note addresses
  * the corpus with wikilinks, which {@link auditLinks} resolves. A homepage does
- * not and cannot: it is published *verbatim* by every publishing mode, including
- * the homepage-only mode two fan-licensed packages ship under, where the content
- * tree is never walked and there is no index for a wikilink to resolve against.
+ * not and cannot: it is published *verbatim* even when the tree contains other
+ * notes. Its body never runs through the wikilink resolver.
  * So a homepage addresses the web the way the web does — markdown links in its
  * body — and this is what looks at those. A dead link on the page a reader
  * arrives at is the one nothing else would report.
@@ -796,8 +781,7 @@ function readAddress(url, packages) {
  *   is why every one is reported — including a bare `/<package>/`, which names
  *   another package's front page. A front page's address *is* its package
  *   prefix, so `/<package>/` is the absolute URL with the host struck off —
- *   host-free, emitted verbatim, and needing no index, which is what lets it
- *   hold in homepage-only mode where the tree is never walked.
+ *   host-free, emitted verbatim, and needing no index.
  * - A **wikilink**, which nothing on this page will ever resolve.
  *
  * **What is not checkable, and is not attempted.** Whether an external URL
@@ -842,7 +826,7 @@ export function auditHomepageLinks(index) {
                 all,
                 at(all),
                 `wikilink ${all} on the package homepage — a homepage is ` +
-                    `published verbatim in every publishing mode, so nothing ` +
+                    `published verbatim, so nothing ` +
                     `resolves it; write a markdown link, package-relative`,
             );
         }
@@ -1004,7 +988,13 @@ export function auditLinks(index) {
                 deadAddresses.push({ ...at, reason: "not-an-address" });
                 continue;
             }
-            if (index.resolveAddress(target)) continue;
+            const resolved = index.resolveAddress(target);
+            if (resolved) {
+                if ((isGmNote(resolved.fm) || resolved.gm) && !isGmNote(note.fm)) {
+                    deadAddresses.push({ ...at, reason: "gm" });
+                }
+                continue;
+            }
             // A stub is in the index, so the refusal can name it. Asked before
             // the foreign manifests, because a local note is what the author
             // meant and reporting it as an unresolved foreign address would
@@ -1019,7 +1009,12 @@ export function auditLinks(index) {
             // a fully qualified target names one package, so there is nothing
             // left to disambiguate, and no ambiguity finding this resolver can
             // report.
-            if (manifestHit(target)) {
+            const manifest = manifestHit(target);
+            if (manifest) {
+                if (manifest.gm && !isGmNote(note.fm)) {
+                    deadAddresses.push({ ...at, reason: "gm" });
+                    continue;
+                }
                 usedManifest.add(encodeAddresses(target).toLowerCase());
                 continue;
             }

package/engine/content-lint.mjs

@@ -394,11 +394,7 @@ export function lintContentTree(
     // thing this guard needs them to do. A tree holding notes is therefore a
     // tree; only a tree holding none is the absent one.
     //
-    // The homepage is not the headline example, though it was once addressed
-    // by the package rather than by a slug — so a `publish.site: homepage`
-    // package had a tree with exactly one note and no key at all. It carries an
-    // address like every other note now; the guard is unchanged, because
-    // what it reads was never the key count.
+    // A tree containing only a homepage still contains one note.
     if (notes.length === 0) {
         findings.push({
             file: path.relative(process.cwd(), contentBase) || contentBase,

package/engine/content-secrets.mjs

@@ -4,8 +4,10 @@
 
 import crypto from "node:crypto";
 import markdownit from "markdown-it";
+import footnotePlugin from "markdown-it-footnote";
+import deflistPlugin from "markdown-it-deflist";
 
-const webMarkdown = markdownit({ html: true });
+const webMarkdown = markdownit({ html: true }).use(footnotePlugin).use(deflistPlugin);
 
 /**
  * Render whole-line `:::secret` blocks for one publishing surface.