@heroiclands/package-build 23.7.0 → 23.8.0

package/engine/content-blocks.mjs

@@ -62,6 +62,7 @@ import { WITHHELD_CLASS, parseHeadingLine, withheldSections } from "./heading-at
  * and a stray `<section>` would close the block early.
  */
 const titleParser = new MarkdownIt({ html: false });
+const structureParser = new MarkdownIt({ html: true });
 
 /** The blocks an author may open, with the heading each takes by default. */
 export const BLOCK_NAMES = Object.freeze({
@@ -99,28 +100,24 @@ function escapeAttribute(value) {
  * @returns {{blocks: Array<{name: string, title: string, id: string, classes: string[], attributes: Record<string, string>, start: number, end: number, body: string}>, errors: Array<{line: number, column: number, message: string}>}}
  */
 export function scanBlocks(source) {
-    const lines = String(source ?? "").split("\n"),
+    const lines = String(source ?? "").split(/\r?\n/),
         blocks = [],
         errors = [];
     const stack = [];
-    let fence = null;
+    // A bare fence can belong to a quote through lazy continuation.
+    // Parser ranges decide whether it can delimit a container.
+    const literalLines = new Set();
+    for (const token of structureParser.parse(String(source ?? ""), {})) {
+        if (
+            !token.map ||
+            !["blockquote_open", "fence", "code_block", "html_block"].includes(token.type)
+        )
+            continue;
+        for (let line = token.map[0]; line < token.map[1]; line++) literalLines.add(line);
+    }
     for (let i = 0; i < lines.length; i++) {
+        if (literalLines.has(i)) continue;
         const line = lines[i];
-        const code = /^ *(`{3,}|~{3,})(.*)$/.exec(line);
-        if (fence) {
-            if (
-                code &&
-                code[1][0] === fence[0] &&
-                code[1].length >= fence.length &&
-                !code[2].trim()
-            )
-                fence = null;
-            continue;
-        }
-        if (code) {
-            fence = code[1];
-            continue;
-        }
         const close = /^ *:::\s*$/.test(line);
         const named = /^ *:::([A-Za-z][A-Za-z0-9-]*)(?:\s+(.*))?$/.exec(line);
         const div = /^ *:::\s+(\{.*)$/.exec(line);
@@ -135,7 +132,7 @@ export function scanBlocks(source) {
             if (!block.body)
                 errors.push({
                     line: block.start + 1,
-                    column: 1,
+                    column: lines[block.start].indexOf(":::") + 1,
                     message: `${block.name} block is empty`,
                 });
             if (!stack.length) blocks.push(block);
@@ -144,7 +141,7 @@ export function scanBlocks(source) {
         if (!close && !named && !div) continue;
         const name = named?.[1] ?? "div",
             raw = named?.[2] ?? div?.[1] ?? "";
-        const at = { line: i + 1, column: 1 };
+        const at = { line: i + 1, column: line.indexOf(":::") + 1 };
         if (name !== "div" && !Object.hasOwn(BLOCK_NAMES, name)) {
             errors.push({ ...at, message: `there is no ${name} block; the blocks are ${names()}` });
             stack.push({ start: i, rejected: true });
@@ -189,27 +186,12 @@ export function scanBlocks(source) {
         if (!block.rejected)
             errors.push({
                 line: block.start + 1,
-                column: 1,
+                column: lines[block.start].indexOf(":::") + 1,
                 message: `${block.name} block needs a closing ::: line`,
             });
     for (const block of blocks) {
-        let literal = null;
         for (let i = block.start + 1; i < block.end; i++) {
-            const marker = /^ *(`{3,}|~{3,})(.*)$/.exec(lines[i]);
-            if (literal) {
-                if (
-                    marker &&
-                    marker[1][0] === literal[0] &&
-                    marker[1].length >= literal.length &&
-                    !marker[2].trim()
-                )
-                    literal = null;
-                continue;
-            }
-            if (marker) {
-                literal = marker[1];
-                continue;
-            }
+            if (literalLines.has(i)) continue;
             if (parseHeadingLine(lines[i])?.startsPage)
                 errors.push({
                     line: i + 1,

package/engine/content-format.yaml

@@ -221,6 +221,9 @@ types:
             - roots
             - cognates
             - callingNames
+            - older
+            - negation
+            - naming
         subTypes:
             - social
             - nature

package/engine/content-index.mjs

@@ -410,23 +410,25 @@ function foundryBlock(entry, system) {
  * @param {string} [absPath] - The file, read only on the failing path to locate
  *   the offending key.
  * @param {string} [contentPackage] - The package this tree compiles as.
+ * @param {string} [raw] - Source text already read by the caller.
  * @returns {void}
  * @throws {Error} When the note authors a derived key. `file` and `position`
  *   ride on the error.
  */
-function assertNoDerivedKeys(frontmatter, relPath, absPath, contentPackage) {
+function assertNoDerivedKeys(frontmatter, relPath, absPath, contentPackage, raw) {
     for (const key of DERIVED_KEYS) {
         if (!Object.hasOwn(frontmatter ?? {}, key)) continue;
         if (key === "package") {
             // Throws with its own wording, and its own position.
-            assertNoDeclaredPackage(frontmatter, { absPath, configured: contentPackage });
+            assertNoDeclaredPackage(frontmatter, { absPath, configured: contentPackage, raw });
         }
         const err = new Error(
             `\`${key}:\` is derived by the content index and cannot be ` +
                 `authored — rename the frontmatter field`,
         );
         err.file = relPath;
-        const position = absPath ? locateFrontmatterKey(absPath, key) : undefined;
+        const position =
+            absPath ? locateFrontmatterKey(absPath, key, undefined, { raw }) : undefined;
         if (position) err.position = position;
         throw err;
     }
@@ -445,6 +447,7 @@ function assertNoDerivedKeys(frontmatter, relPath, absPath, contentPackage) {
  * @param {string} options.relPath - Its path below the content root, POSIX-separated.
  * @param {string} [options.absPath] - The file, read only on the failing path to
  *   locate the offending key.
+ * @param {string} [options.raw] - Source text already read by the caller.
  * @param {string} options.contentPackage - The package the tree compiles as.
  * @param {string} [options.body] - The note's markdown body, for its anchors
  *   and for the one question that decides whether the note publishes a page. A
@@ -473,6 +476,7 @@ export function buildIndexRecord({
     frontmatter,
     relPath,
     absPath,
+    raw,
     contentPackage,
     body,
     bodyLine,
@@ -481,7 +485,7 @@ export function buildIndexRecord({
     dateContext,
     resolveRole,
 }) {
-    assertNoDerivedKeys(frontmatter, relPath, absPath, contentPackage);
+    assertNoDerivedKeys(frontmatter, relPath, absPath, contentPackage, raw);
 
     const posix = relPath.split(path.sep).join("/");
     const folder = posix.includes("/") ? posix.slice(0, posix.lastIndexOf("/")) : "";
@@ -490,9 +494,7 @@ export function buildIndexRecord({
     } catch (error) {
         error.file = absPath ?? relPath;
         if (absPath && error.keyPath) {
-            const yamlText = fs
-                .readFileSync(absPath, "utf8")
-                .match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1];
+            const yamlText = (raw ?? rawNote(absPath)).match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1];
             const locate = (/** @type {any} */ found) => {
                 const position = positionOfYamlPath(yamlText, found.keyPath, {
                     key: found.addressKey,
@@ -540,7 +542,7 @@ export function buildIndexRecord({
                     stub ? null : (
                         [
                             ...collectAnchors(body, bodyLine, resolveRole),
-                            ...eventAnchors(frontmatter, rawNote(absPath)),
+                            ...eventAnchors(frontmatter, raw ?? rawNote(absPath)),
                         ]
                             .sort((a, b) => (a.line ?? 0) - (b.line ?? 0))
                             .map((a) => ({
@@ -659,6 +661,7 @@ export function indexRecordsForNote({
     bodyLine,
     relPath,
     absPath,
+    raw,
     contentPackage,
     manifest,
     addressContext,
@@ -672,6 +675,7 @@ export function indexRecordsForNote({
         bodyLine,
         relPath,
         absPath,
+        raw,
         contentPackage,
         manifest,
         addressContext,
@@ -783,10 +787,14 @@ function cultureTuple(value) {
  *   immediate parent whose package is not this one.
  * @param {object[]} [options.problems] - Receives each conflict as a finding.
  *   Omitted, every conflict is collected and one Error lists them all.
+ * @param {Map<string, {raw: string}>} [options.parsed] - Notes already read, keyed by file.
  * @returns {Array<Record<string, any>>} The same records.
  * @throws {Error} When `problems` is omitted and any note's sources disagree.
  */
-export function resolveCultures(records, { contentPackage, contentBase, foreignRecord, problems }) {
+export function resolveCultures(
+    records,
+    { contentPackage, contentBase, foreignRecord, problems, parsed },
+) {
     // Each note under every key a link may name it by: its record's canonical
     // address, and its page address in the `note` system, which is what a
     // `data.parents`, `data.seat` or `data.government` link names.
@@ -879,7 +887,7 @@ export function resolveCultures(records, { contentPackage, contentBase, foreignR
      */
     const conflict = (record, keyPath, subject, distinct) => {
         const file = contentBase ? noteFile(contentBase, record) : record.file?.path;
-        const raw = contentBase && fs.existsSync(file) ? fs.readFileSync(file, "utf8") : undefined;
+        const raw = parsed?.get(file)?.raw ?? (contentBase ? rawNote(file) : undefined);
         let position = positionOfFrontmatterPath(raw, keyPath, { key: true });
         if (position.line === undefined && keyPath.length > 1)
             position = positionOfFrontmatterPath(raw, ["data"], { key: true });
@@ -1026,9 +1034,9 @@ export function resolveCultures(records, { contentPackage, contentBase, foreignR
  * @param {(key: string) => ({culture?: unknown}|undefined)} [options.foreignRecord] -
  *   Another package's entry for a canonical address, read for a parent that
  *   package publishes; see {@link resolveCultures}.
- * @param {Map<string, {body: string, frontmatter: object|null}>} [options.parsed] -
- *   Filled with each note's body and its frontmatter as authored, keyed by the
- *   note's file, so a later pass reads the notes this walk already parsed.
+ * @param {Map<string, {body: string, frontmatter: object|null, raw: string, bodyLine?: number, bodyColumn?: number}>} [options.parsed] -
+ *   Filled with each note's source text, body coordinates and frontmatter as
+ *   authored, keyed by file, for reuse throughout the command.
  * @returns {Array<Record<string, any>>} The records, in a total order that does
  *   not depend on directory-read order.
  */
@@ -1042,7 +1050,7 @@ export function collectContentIndex(
         problems,
         addressContext,
         foreignRecord,
-        parsed,
+        parsed = new Map(),
     },
 ) {
     const records = [];
@@ -1115,10 +1123,16 @@ export function collectContentIndex(
 
     // Each recorded note with its body, for the words its prose cites.
     const bodies = [];
-    for (const { frontmatter, body, bodyLine, absPath } of parsedNotes) {
+    for (const { frontmatter, body, bodyLine, bodyColumn, raw, absPath } of parsedNotes) {
         // Before the index derives anything onto the frontmatter, so a later
         // pass reads the note as authored.
-        parsed?.set(absPath, { body, frontmatter: structuredClone(frontmatter) });
+        parsed.set(absPath, {
+            body,
+            bodyLine,
+            bodyColumn,
+            raw,
+            frontmatter: structuredClone(frontmatter),
+        });
         const fm = frontmatter ?? {};
         applyComputedBeingAge(fm, present, dates);
         const relPath = path.relative(contentBase, absPath);
@@ -1127,6 +1141,7 @@ export function collectContentIndex(
                 frontmatter: fm,
                 relPath,
                 absPath,
+                raw,
                 contentPackage,
                 body,
                 bodyLine,
@@ -1142,9 +1157,7 @@ export function collectContentIndex(
                 err.identity = { type: fm.type, shortcode: fm.shortcode };
                 err.keyPath = ["shortcode"];
                 err.message = `shortcode "${fm.shortcode}" is not strictly alphanumeric — lowercase letters and digits only`;
-                const yamlText = fs
-                    .readFileSync(absPath, "utf8")
-                    .match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1];
+                const yamlText = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/)?.[1];
                 err.position = positionOfYamlPath(yamlText, err.keyPath);
                 if (err.position.line) err.position.line++;
             }
@@ -1186,13 +1199,13 @@ export function collectContentIndex(
     // Every note record exists and every Address in it is a tuple, so a parent
     // is found by its canonical address. Before the sort, which reads nothing
     // the pass writes.
-    resolveCultures(records, { contentPackage, contentBase, foreignRecord, problems });
+    resolveCultures(records, { contentPackage, contentBase, foreignRecord, problems, parsed });
     const cultureNotes = records
         .filter((record) => isNoteRecord(record) && record.type === "lore")
         .map((record) => ({
             fm: record,
             file: noteFile(contentBase, record),
-            raw: fs.readFileSync(noteFile(contentBase, record), "utf8"),
+            raw: parsed.get(noteFile(contentBase, record)).raw,
         }));
     const cultureByKey = new Map(
         cultureNotes.map((note) => [
@@ -1352,7 +1365,7 @@ function dependencyAddresses(config) {
  *   aborting the derivation. Omitted, the note throws — which is the contract
  *   the emitter needs, since an index missing a note asserts that it does not
  *   exist.
- * @param {Map<string, {body: string, frontmatter: object|null}>} [opts.parsed] -
+ * @param {Map<string, {body: string, frontmatter: object|null, raw: string, bodyLine?: number, bodyColumn?: number}>} [opts.parsed] -
  *   Filled with each note's body and authored frontmatter, keyed by the note's
  *   file. Handed to {@link module:engine/sql-tables.prepareTreeSqlTables}, it
  *   spares that pass reading and parsing every note again.

package/engine/content-poetry.mjs

@@ -71,9 +71,12 @@ export function poetryMarkdown(body) {
         .join("\n\n");
 }
 
+import MarkdownIt from "markdown-it";
 import { slugify } from "./content-slug.mjs";
 import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
 
+const structureParser = new MarkdownIt({ html: true });
+
 /** Read poetry code fences; start/end are inclusive zero-based source lines.
  * @param {string} source - Authored Markdown.
  */
@@ -81,8 +84,14 @@ export function scanPoetry(source) {
     const lines = String(source ?? "").split("\n"),
         blocks = [],
         errors = [];
+    const literalLines = new Set();
+    for (const token of structureParser.parse(String(source ?? ""), {})) {
+        if (!token.map || !["blockquote_open", "html_block"].includes(token.type)) continue;
+        for (let line = token.map[0]; line < token.map[1]; line++) literalLines.add(line);
+    }
     let opening = null;
     for (let i = 0; i < lines.length; i++) {
+        if (literalLines.has(i)) continue;
         const match = /^ *(`{3,}|~{3,})(.*)$/.exec(lines[i]);
         if (opening) {
             if (

package/engine/diagnostics.mjs

@@ -249,15 +249,20 @@ export function positionInFrontmatter(raw, key, value = undefined, { topLevel =
  *   {@link positionInFrontmatter}.
  * @param {boolean} [options.topLevel=false] - Require the key at column 1, so
  *   an identically named nested key cannot answer for it.
+ * @param {string} [options.raw] - Source text already read by the caller.
  * @returns {{line?: number, column?: number}|undefined} Spreadable position
  *   fields, dropped rather than guessed when the file cannot be read or the key
  *   cannot be found — as `formatDiagnostic` requires.
  */
-export function locateFrontmatterKey(absPath, key, value = undefined, { topLevel = false } = {}) {
-    if (!absPath) return undefined;
-    let raw;
+export function locateFrontmatterKey(
+    absPath,
+    key,
+    value = undefined,
+    { topLevel = false, raw } = {},
+) {
+    if (!absPath && raw === undefined) return undefined;
     try {
-        raw = fs.readFileSync(absPath, "utf8");
+        raw ??= fs.readFileSync(absPath, "utf8");
     } catch {
         return undefined;
     }
@@ -306,6 +311,9 @@ export function positionOfLiteral(text, needle, occurrence = 1) {
     };
 }
 
+/** The most recently located text; retaining one document bounds memory. */
+let locatedYaml;
+
 /**
  * Where a **key or value in a YAML document** sits, addressed by its path.
  *
@@ -315,11 +323,10 @@ export function positionOfLiteral(text, needle, occurrence = 1) {
  * first occurrence is routinely not the one the finding is about — which is the
  * one thing the located form exists to prevent.
  *
- * A path resolves the exact node instead. The document is re-parsed here rather
- * than threaded from the loader because the loader returns plain data: `yaml`
- * discards ranges once a document is materialised, and carrying a parallel
- * position tree through configuration resolution would be a second
- * representation of the same file to keep in step.
+ * A path resolves the exact node. The most recently located text retains its
+ * document and line counter, so several findings in one note share a parse.
+ * A different text replaces that entry, including an edited copy of the same
+ * file. The loader returns plain data without source ranges.
  *
  * Every failure — unparseable text, an `.mjs` configuration, a path that
  * resolves to nothing — yields `{}`, so a caller spreads the result and the
@@ -348,9 +355,15 @@ export function positionOfYamlPath(text, keyPath, { key = false } = {}) {
     if (!Array.isArray(keyPath) || keyPath.length === 0) return {};
 
     let node;
-    const counter = new LineCounter();
+    let counter;
     try {
-        const doc = YAML.parseDocument(text, { lineCounter: counter });
+        if (locatedYaml?.text !== text) {
+            const lineCounter = new LineCounter();
+            const doc = YAML.parseDocument(text, { lineCounter });
+            locatedYaml = { text, doc, counter: lineCounter };
+        }
+        const { doc } = locatedYaml;
+        counter = locatedYaml.counter;
         // `keepScalar` returns the Scalar node rather than its value, which is
         // the only form carrying a range.
         node = doc.getIn(keyPath, true);

package/engine/frontmatter-lint.mjs

@@ -1541,7 +1541,7 @@ export function lintNote(
         for (const field of fields) {
             if (note.inheritedCultureFields?.has(field.name)) continue;
             if (typeof field.check !== "function") continue;
-            findings.push(...field.check(note, { index }));
+            findings.push(...field.check(note, { index, addressContext: referenceContext }));
         }
         // A check the type declares of the whole note, with the same index.
         if (typeof entry.check === "function") findings.push(...entry.check(note, { index }));

package/engine/generate.mjs

@@ -38,7 +38,7 @@
  * The HeroicLands vault is not a build input for SoHL content.
  */
 
-import { noteAddressContext } from "./note-addresses.mjs";
+import { noteAddressContext, decodeNoteAddresses } from "./note-addresses.mjs";
 import { GENERATED_DRAWING_DIR } from "./generated-sections.mjs";
 import fs from "fs";
 import path from "path";
@@ -54,7 +54,7 @@ import { Hm3Actors } from "../hm3/actors.mjs";
 import { Macros } from "./macros.mjs";
 import { Scenes } from "./scenes.mjs";
 import { Bundles } from "./bundles.mjs";
-import { statsForPack, parseMarkdownFile, folderFilename } from "./helpers.mjs";
+import { statsForPack, folderFilename } from "./helpers.mjs";
 import {
     buildFolderNoteIndex,
     collectFolderNotes,
@@ -800,7 +800,10 @@ export async function generatePacksJson({ only, config = loadPackConfig() } = {}
     // every type a system deliberately does not map, which is exactly the
     // silence the rule requires. Independent of `only`, since it is a fact about the
     // configured pack list rather than about which passes this run executes.
-    const unclaimed = unclaimedNoteFindings(config, undefined, { records: corpus.records });
+    const unclaimed = unclaimedNoteFindings(config, undefined, {
+        records: corpus.records,
+        parsed: corpus.parsed,
+    });
     for (const finding of unclaimed) emitDiagnostic(finding);
 
     fs.mkdirSync(config.paths.packJson, { recursive: true });
@@ -831,22 +834,8 @@ export async function generatePacksJson({ only, config = loadPackConfig() } = {}
     try {
         folderNotes = buildFolderNoteIndex(
             collectFolderNotes(
-                // The corpus this compile derived picks the notes; the
-                // file supplies their frontmatter, and this is one of the few
-                // places where that distinction is load-bearing rather than
-                // incidental.
-                //
-                // `collectFolderNotes` treats `fm.id` as an **authored pin**,
-                // which wins over the id it derives under the folder namespace.
-                // A record's `id` is not that: the index fills it in for every
-                // addressable note, so handing records straight over
-                // would make every folder look pinned. The *value*
-                // would be right either way — the index derives a folder's id
-                // under the folder namespace, so the two agree — but `derivedId`
-                // would not, and it is what tells an author whether a duplicate
-                // id was two pins or two addresses. The index cannot tell a pin
-                // from a derivation, so the note is read — and only folder notes
-                // are, 79 of `sohl`'s 1,685 rather than all of them.
+                // Folder pins are authored ids; index-derived ids must not
+                // turn an unpinned folder into a pinned one.
                 corpus.records
                     .filter(
                         (record) =>
@@ -856,9 +845,10 @@ export async function generatePacksJson({ only, config = loadPackConfig() } = {}
                     .map((record) => {
                         const absPath = noteFile(contentBase, record);
                         return {
-                            frontmatter: parseMarkdownFile(absPath, {
-                                addressContext: noteAddressContext(config),
-                            }).frontmatter,
+                            frontmatter: decodeNoteAddresses(
+                                structuredClone(corpus.parsed.get(absPath).frontmatter),
+                                noteAddressContext(config),
+                            ),
                             absPath,
                         };
                     }),

package/engine/helpers.mjs

@@ -233,17 +233,18 @@ export function renderFoundryMarkdown(body, figures, footnoteNumbers, docId, res
 /**
  * Parses a markdown file with YAML frontmatter.
  *
- * Returns `{ frontmatter, body, description, bodyLine, bodyColumn }` where
+ * Returns `{ frontmatter, body, description, bodyLine, bodyColumn, raw }` where
  * `body` is the trimmed raw markdown after the frontmatter block, and
- * `description` is `body` rendered to HTML. `bodyLine` / `bodyColumn` are the
+ * `description` is `body` rendered to HTML. The full source is retained as
+ * `raw` for diagnostic locations. `bodyLine` / `bodyColumn` are the
  * 1-based **file** position of the body's first character, which is what turns
  * an offset within `body` into a position a diagnostic can name — see
  * {@link positionInBody}. If the file has no frontmatter block, returns
- * `{ frontmatter: null, body: "", description: "" }` with a warn log, and no
+ * `{ frontmatter: null, body: "", description: "", raw }` and no
  * position: there is no body to have one.
  * @param {string} filePath - Markdown file to read.
  * @param {{addressContext?: object}} [opts] - Address defaults for decoded fields.
- * @returns {{frontmatter: object|null, body: string, description: string,
+ * @returns {{frontmatter: object|null, body: string, description: string, raw: string,
  *   bodyLine?: number, bodyColumn?: number, parseError?: {message: string,
  *   line?: number, column?: number}}} Parsed note and body position.
  */
@@ -251,7 +252,7 @@ export function parseMarkdownFile(filePath, { addressContext } = {}) {
     const content = fs.readFileSync(filePath, "utf8");
     const fmMatch = content.match(/^---\n([\s\S]*?)\n---\n?([\s\S]*)$/);
     if (!fmMatch) {
-        return { frontmatter: null, body: "", description: "" };
+        return { frontmatter: null, body: "", description: "", raw: content };
     }
     let frontmatter;
     try {
@@ -264,6 +265,7 @@ export function parseMarkdownFile(filePath, { addressContext } = {}) {
             frontmatter: null,
             body: "",
             description: "",
+            raw: content,
             parseError: {
                 message: `YAML parse error: ${message}`,
                 ...(Number.isInteger(location?.line) ? { line: location.line + 1 } : {}),
@@ -295,7 +297,7 @@ export function parseMarkdownFile(filePath, { addressContext } = {}) {
     const before = content.slice(0, bodyStart);
     const bodyLine = before.split("\n").length;
     const bodyColumn = bodyStart - before.lastIndexOf("\n");
-    return { frontmatter, body, description, bodyLine, bodyColumn };
+    return { frontmatter, body, description, bodyLine, bodyColumn, raw: content };
 }
 
 /**

package/engine/infobox.mjs

@@ -277,6 +277,9 @@ export const GEAR_UNITS = Object.freeze({
  *   unit?: string, group?: string, phrase?: (value: any) => string}>>}
  */
 export const NOTE_FIELD_PRESENTATION = Object.freeze({
+    seeAlso: Object.freeze({
+        withheld: "navigation machinery, rendered in its own reading section",
+    }),
     ...DURATION_LABELS,
     ...GEAR_UNITS,
 

package/engine/journals.mjs

@@ -50,6 +50,7 @@
  */
 
 import log from "loglevel";
+import { seeAlsoEntries, seeAlsoMarkdown } from "./see-also.mjs";
 
 import path from "node:path";
 
@@ -825,7 +826,16 @@ export class Journals extends BasePackCompiler {
         return buildJournalEntry({
             id,
             name,
-            markdown,
+            markdown: [
+                markdown,
+                seeAlsoMarkdown(
+                    seeAlsoEntries(fm, (ref) => resolveReference(this.linkIndex, ref)),
+                    linkToUuid,
+                    1,
+                ),
+            ]
+                .filter(Boolean)
+                .join("\n\n"),
             resolveRole: (pathname) => roles.get(pathname),
             infoboxes: boxes.map((box) => ({
                 id: box.id,