@heroiclands/package-build 23.9.0 → 23.11.0

package/engine/sql-tables.mjs

@@ -32,6 +32,7 @@ import { expandContentTables } from "./content-tables.mjs";
 import { NOTE_VOCABULARY, isGmNote } from "./note-vocabulary.mjs";
 import { encodeAddresses, flattenPublishedAddresses } from "./address-values.mjs";
 import { EVENT_COLUMNS, EVENT_SORT_COLUMNS, eventRows } from "./event-rows.mjs";
+import { NAME_COLUMNS, namesRows } from "./name-rows.mjs";
 import {
     GLOSSARY_COLUMNS,
     AFFIX_COLUMNS,
@@ -272,6 +273,7 @@ export async function openNotesDatabase(
     await connection.run("SET threads=1");
     await createRelations(connection, jsonl, encoded, "", audience);
     await createEventRelation(connection, path.join(base, "events.jsonl"), encoded, "", audience);
+    await createNameRelation(connection, path.join(base, "names.jsonl"), encoded, "", audience);
     await createWordRelations(connection, path.join(base, "notes"), encoded, "", audience);
 
     // One schema per declared dependency, so `FROM sohl.notes` reads the notes
@@ -301,6 +303,13 @@ export async function openNotesDatabase(
             `${schema}.`,
             audience,
         );
+        await createNameRelation(
+            connection,
+            flat.replace(/\.jsonl$/, "-names.jsonl"),
+            depRecords,
+            `${schema}.`,
+            audience,
+        );
         await createWordRelations(
             connection,
             flat.replace(/\.jsonl$/, ""),
@@ -334,6 +343,7 @@ export async function openNotesDatabase(
     await connection.run(`CREATE VIEW ${WITH_STUBS_SCHEMA}.notes AS SELECT * FROM entries`);
     for (const relation of [
         "events",
+        "names",
         "words",
         "affixes",
         "fields",
@@ -542,6 +552,41 @@ async function createEventRelation(connection, file, records, prefix, audience)
     await createTableFromFile(connection, `${prefix}events`, readJsonAuto(file));
 }
 
+/**
+ * Create authored name rows from own-note records, with audience filtering and
+ * fixed scalar types even when every optional classification is null.
+ * @param {object} connection - An open DuckDB connection.
+ * @param {string} file - Where to write the rows.
+ * @param {object[]} records - Index records, every Address a string.
+ * @param {string} prefix - A schema to qualify the relation name with.
+ * @param {"all"|"public"} audience - Whether to leave out GM notes.
+ * @returns {Promise<void>}
+ */
+async function createNameRelation(connection, file, records, prefix, audience) {
+    const rows = namesRows(
+        audience === "public" ? records.filter((record) => !isGmNote(record)) : records,
+    );
+    const columnTypes = NAME_COLUMNS.map((column) => [
+        column,
+        column === "line" || column === "column" ? "BIGINT" : "VARCHAR",
+    ]);
+    if (!rows.length) {
+        const columns = columnTypes.map(([column, type]) => `NULL::${type} AS "${column}"`);
+        await connection.run(
+            `CREATE VIEW ${prefix}names AS SELECT ${columns.join(", ")} WHERE false`,
+        );
+        return;
+    }
+    fs.writeFileSync(file, rows.map((row) => JSON.stringify(row)).join("\n"));
+    const schema = columnTypes.map(([column, type]) => `'${column}': '${type}'`).join(", ");
+    await createTableFromFile(
+        connection,
+        `${prefix}names`,
+        `SELECT * FROM read_json('${file.replace(/'/g, "''")}', columns={${schema}}, ` +
+            "format='newline_delimited', maximum_object_size=20000000)",
+    );
+}
+
 /**
  * Create a relation as a table, so the JSONL behind it is parsed once when the
  * database opens rather than on every query. A view over `read_json_auto`
@@ -1303,21 +1348,22 @@ export function attachGeneratedSections(prepared, generated) {
  * @param {object} [config] - The resolved build configuration.
  * @returns {Promise<void>}
  */
-async function attachPreparedAnchors(prepared, records, contentBase, parsed, config) {
+async function attachPreparedAnchors(prepared, records, contentBase, parsed, config, syntax) {
     const { entriesForNote, foundryIdentities } = await import("./foundry-entries.mjs");
-    const identities = config ? foundryIdentities(config) : undefined;
+    const identities = config ? { ...foundryIdentities(config), syntax } : undefined;
     for (const record of records) {
         if (!isNoteRecord(record)) continue;
         const file = noteFile(contentBase, record);
         const results = prepared.get(file);
         if (!results) continue;
+        if (syntax) results.syntax = syntax;
         const { body } = parsed.get(file) ?? parseMarkdownFile(file);
         const expanded = expandContentTables(body, {
             source: file,
             sqlTables: results,
             pageLists: prepared.pageLists?.get(file),
         }).markdown;
-        results.anchors = collectAnchors(expanded);
+        results.anchors = collectAnchors(expanded, 1, undefined, syntax);
         if (!identities || !record.address?.slug) continue;
         const frontmatter = authoredFrontmatter(record);
         const entries = entriesForNote(
@@ -1429,13 +1475,23 @@ export async function cachedDependencies(config) {
  * @param {Map<string, object>} [opts.foreignIndex] - The fetched indexes the
  *   generated sections take in, where the caller holds them already; absent,
  *   they are read from the cache.
+ * @param {import("./content-session.mjs").ContentSyntax} [opts.syntax] - Exact-text scanner projections.
  * @returns {Promise<Map<string, object[]>|undefined>} Results by note path,
  *   carrying `inline` and `pageLists` beside them, or nothing when the tree
  *   holds no such directive and no note is given a generated section.
  */
 export async function prepareTreeSqlTables(
     contentBase,
-    { config, skipDirectories, records, parsed, database, audience = "all", foreignIndex } = {},
+    {
+        config,
+        skipDirectories,
+        records,
+        parsed,
+        database,
+        audience = "all",
+        foreignIndex,
+        syntax,
+    } = {},
 ) {
     // Imported here rather than at module scope: the index reaches the pack
     // compilers through `manifest-emit` → `journals`, so a static import from a
@@ -1514,7 +1570,7 @@ export async function prepareTreeSqlTables(
         pageOnly.inline = new Map();
         pageOnly.pageLists = preparePageLists(indexRecords, sources);
         attachGeneratedSections(pageOnly, derivedOnly);
-        await attachPreparedAnchors(pageOnly, indexRecords, contentBase, notes, config);
+        await attachPreparedAnchors(pageOnly, indexRecords, contentBase, notes, config, syntax);
         return pageOnly;
     }
     // A cell links only where the address it would emit resolves, so a table
@@ -1559,7 +1615,7 @@ export async function prepareTreeSqlTables(
         });
         prepared.inline = await prepareInlineSqlExpressions(db, sources);
         attachGeneratedSections(prepared, generated);
-        await attachPreparedAnchors(prepared, indexRecords, contentBase, notes, config);
+        await attachPreparedAnchors(prepared, indexRecords, contentBase, notes, config, syntax);
         return prepared;
     } finally {
         if (!database) await db.close();
@@ -1578,11 +1634,13 @@ export async function prepareTreeSqlTables(
  * @param {object[]} [opts.records] - Complete index records already derived.
  * @param {Map<string, {body: string, frontmatter: object|null}>} [opts.parsed] - Parsed notes.
  * @param {Map<string, object>} [opts.foreignIndex] - Published dependency indexes.
+ * @param {(audience: "all"|"public") => Promise<Map<string, object[]>|undefined>} [opts.prepareAudience] -
+ *   Context-bound preparation shared with other operations in the same session.
  * @returns {Promise<Map<string, object[]>|undefined>} Prepared tables by source.
  */
 export async function prepareLinkSqlTables(
     contentBase,
-    { config, skipDirectories, records, parsed, foreignIndex } = {},
+    { config, skipDirectories, records, parsed, foreignIndex, prepareAudience } = {},
 ) {
     const { indexRecordsFor } = await import("./content-index.mjs");
     const notes = parsed ?? new Map();
@@ -1619,14 +1677,17 @@ export async function prepareLinkSqlTables(
     selected.pageLists = new Map();
     selected.inline = new Map();
     for (const audience of new Set(sources.values())) {
-        const prepared = await prepareTreeSqlTables(contentBase, {
-            config,
-            skipDirectories,
-            records: allRecords,
-            parsed: notes,
-            foreignIndex,
-            audience,
-        });
+        const prepared =
+            prepareAudience ?
+                await prepareAudience(audience)
+            :   await prepareTreeSqlTables(contentBase, {
+                    config,
+                    skipDirectories,
+                    records: allRecords,
+                    parsed: notes,
+                    foreignIndex,
+                    audience,
+                });
         for (const [file, sourceAudience] of sources) {
             if (sourceAudience !== audience) continue;
             if (prepared?.has(file)) selected.set(file, prepared.get(file));

package/engine/stub-lint.mjs

@@ -124,13 +124,14 @@ function checkNote({ fm, body, file, raw }) {
  * @param {object} opts
  * @param {readonly object[]} opts.records - Index records the caller derived.
  * @param {string} [opts.contentPackage] - Named in the counts line.
+ * @param {Map<string, import("./content-session.mjs").ContentNoteSource>} [opts.parsed] - Captured sources, with the file reader as fallback.
  * @returns {{findings: object[], counts: {full: number, draft: number,
  *   stub: number}, byType: Array<{type: string, full: number, draft: number,
  *   stub: number}>, oldestDrafts: Array<{file: string, modified: Date}>,
  *   summary: string[]}} The findings, the ladder's counts, and the lines a
  *   reader is shown as prose rather than as findings.
  */
-export function lintNoteStates(contentBase, { records, contentPackage } = {}) {
+export function lintNoteStates(contentBase, { records, contentPackage, parsed } = {}) {
     const findings = [];
     const counts = { full: 0, draft: 0, stub: 0 };
     /** @type {Map<string, {full: number, draft: number, stub: number}>} */
@@ -149,8 +150,8 @@ export function lintNoteStates(contentBase, { records, contentPackage } = {}) {
         const absPath = noteFile(contentBase, record);
         const file = path.relative(process.cwd(), absPath);
         const fm = authoredFrontmatter(record);
-        const { body } = parseMarkdownFile(absPath);
-        const raw = fs.readFileSync(absPath, "utf8");
+        const source = parsed?.get(absPath) ?? parseMarkdownFile(absPath);
+        const { body, raw } = source;
 
         // The ladder, read exactly as the `entries` view reads it: the absent
         // address is the state, not a second body test beside it. A note with

package/engine/web-wikilinks.mjs

@@ -41,7 +41,8 @@
 // cannot drift apart on it: they disagreed once over the unlabelled hyphen
 // form, which the packs showed as a raw shortcode and the knowledgebase as a
 // name.
-import { readWikilink } from "./wikilink-syntax.mjs";
+import { collectAnchors } from "./anchors.mjs";
+import { presentWikilink, readWikilink } from "./wikilink-syntax.mjs";
 import { readQualifier } from "./wikilinks.mjs";
 import { replaceOutsideCode } from "./code-fences.mjs";
 // The canonical `package-system-type-shortcode` key, so a package-qualified
@@ -354,6 +355,7 @@ export function resolveWebWikilinks(body, ctx) {
     // same counting the checker does, and what turns a finding into a
     // `file:line:column:` diagnostic rather than a note-wide one.
     const seen = new Map();
+    let ownAnchors = ctx.noteAnchors;
     /**
      * Records a finding against one authored literal.
      *
@@ -404,18 +406,28 @@ export function resolveWebWikilinks(body, ctx) {
     // Code is verbatim: a `[[…]]` inside a code fence, an indented block or an
     // inline span is source text, not a link.
     return replaceOutsideCode(embedded.markdown, WIKILINK, (all, rawInner) => {
-        const parsed = readWikilink(rawInner, {
-            package: ctx.contentPackage,
-            system: "note",
-            types: ctx.contentTypes ?? new Set(),
-            packages: ctx.packages,
-            noIndexPackages: ctx.noIndexPackages,
-        });
+        const parsed = readWikilink(
+            rawInner,
+            {
+                package: ctx.contentPackage,
+                system: "note",
+                types: ctx.contentTypes ?? new Set(),
+                packages: ctx.packages,
+                noIndexPackages: ctx.noIndexPackages,
+            },
+            all,
+        );
         const { rawTarget: target, anchor, display } = parsed;
         // An empty label is not a label: `[[x|]]` addresses the target and
         // shows its name, so `""` falls through to the same place `null` does.
         // One reading, from {@link authoredLabel}.
         const label = authoredLabel({ display });
+        if (parsed.attributes?.problems.length)
+            return report(
+                all,
+                { target, reason: "invalid-attributes", problems: parsed.attributes.problems },
+                label ?? target,
+            );
 
         // **Every link carries a label**. Without one there is nothing
         // to resolve against, and nothing to show either, a shortcode being an
@@ -445,7 +457,11 @@ export function resolveWebWikilinks(body, ctx) {
                     label ?? anchor,
                 );
             }
-            return `[${label ?? ctx.captionLabels?.get(anchor) ?? anchor}](#${slugify(anchor)})`;
+            return presentWikilink(
+                `[${label ?? ctx.captionLabels?.get(anchor) ?? anchor}](#${slugify(anchor)})`,
+                parsed,
+                { noteAnchors: (ownAnchors ??= collectAnchors(body)) },
+            );
         }
 
         // The canonical separator has to be resolved, not merely
@@ -480,7 +496,7 @@ export function resolveWebWikilinks(body, ctx) {
                     label ?? hit.name ?? target,
                 );
             }
-            if (anchor && hit.url && !hasAnchor(hit.noteAnchors ?? hit.anchors, anchor)) {
+            if (anchor && !hasAnchor(hit.noteAnchors ?? hit.anchors, anchor)) {
                 return report(
                     all,
                     { target, reason: "unknown-anchor", anchor, addressed: true },
@@ -506,8 +522,13 @@ export function resolveWebWikilinks(body, ctx) {
             // Presentation only — the href above is unchanged, and a
             // `[[#anchor]]` self-link is not marked because the reader is
             // already on the page it would be telling them about.
-            if (!hit.draft) return link;
-            return ctx.output === "book" ? `${link} (draft)` : draftLink(link);
+            return presentWikilink(
+                !hit.draft ? link
+                : ctx.output === "book" ? `${link} (draft)`
+                : draftLink(link),
+                parsed,
+                hit,
+            );
         }
 
         // **An address resolving nowhere is a failure, unconditionally**.

package/engine/wikilink-syntax.mjs

@@ -11,6 +11,9 @@
  * SPDX-License-Identifier: GPL-3.0-or-later
  */
 
+import { parseExtensionAttributes, refusedAttributes } from "./extension-attributes.mjs";
+import { isGmNote } from "./note-vocabulary.mjs";
+
 import { parseAddress, isAddressTuple, splitAnchor } from "./address.mjs";
 
 /**
@@ -67,7 +70,7 @@ import { parseAddress, isAddressTuple, splitAnchor } from "./address.mjs";
  * copies of the exclusion is three places for it to be forgotten. An embed's
  * own grammar is {@link module:engine/content-embeds}.
  */
-export const WIKILINK = /(?<!!)\[\[([^\]\n]+)\]\]/g;
+export const WIKILINK = /(?<!!)\[\[([^\]\n]+)\]\](?:\{(?:[^{}"\n]|"(?:\\.|[^"\\\n])*")*\})?/g;
 
 /**
  * The parts of a wikilink's interior.
@@ -80,6 +83,7 @@ export const WIKILINK = /(?<!!)\[\[([^\]\n]+)\]\]/g;
  * @property {string} anchor - The `#section` slug, `""` when there is none.
  * @property {string|null} display - The text after `|`, or `null` when the link
  *   is unlabelled. `null` and `""` differ: an author may write `[[x|]]`.
+ * @property {ReturnType<typeof parseExtensionAttributes>} [attributes] - Trailing extension attributes.
  * @property {boolean} labelled - Whether a `|` was present at all. A link
  *   without one addresses nothing and is a finding — see
  *   {@link unlabelledLinkMessage} — so every reader has to be able to ask.
@@ -92,9 +96,10 @@ export const WIKILINK = /(?<!!)\[\[([^\]\n]+)\]\]/g;
  * not the whole link, so a caller that has already matched does not re-match.
  *
  * @param {string} rawInner - The text between `[[` and `]]`.
+ * @param {string} [literal] - Whole matched link, including trailing attributes.
  * @returns {ParsedWikilink} The parts, each trimmed.
  */
-export function parseWikilink(rawInner) {
+export function parseWikilink(rawInner, literal = "") {
     // A pipe inside a markdown table cell is escaped as `\|`; undo that before
     // looking for the label separator, or the cell's own escape reads as one.
     const inner = String(rawInner ?? "").replace(/\\\|/g, "|");
@@ -108,7 +113,18 @@ export function parseWikilink(rawInner) {
     // link and a field cannot disagree about where the anchor starts.
     const { address: target, anchor = "" } = splitAnchor(linkPart);
 
-    return { inner: inner.trim(), target, anchor, display, labelled };
+    const suffix = literal.slice(literal.indexOf("]]") + 2);
+    const attributes =
+        suffix.startsWith("{") ? parseExtensionAttributes(suffix.slice(1, -1)) : null;
+    if (attributes) attributes.problems.push(...refusedAttributes(attributes.values));
+    return {
+        inner: inner.trim(),
+        target,
+        anchor,
+        display,
+        labelled,
+        ...(attributes ? { attributes } : {}),
+    };
 }
 
 /**
@@ -193,6 +209,7 @@ export function unlabelledLinkMessage(target) {
  */
 export const LINK_FINDING_REASONS = Object.freeze(
     new Set([
+        "invalid-attributes",
         "unlabelled",
         "not-an-address",
         "not-lowercase",
@@ -201,7 +218,6 @@ export const LINK_FINDING_REASONS = Object.freeze(
         "not-an-asset",
         "unresolved",
         "stub",
-        "gm",
         "ambiguous",
         "unknown-anchor",
         "event-anchor",
@@ -323,6 +339,7 @@ export function ambiguousAddressMessage(target, packages = []) {
  * @param {string} [finding.stub] - For `stub`, where the stub is.
  * @param {string} [finding.shortcode] - For `shortcode-not-lowercase`, the
  *   shortcode as written.
+ * @param {string[]} [finding.problems] - Invalid attribute diagnostics.
  * @param {string} [finding.declared] - For `shortcode-not-lowercase`, the
  *   lowercase spelling, when it is a declared shortcode.
  * @returns {string} The message.
@@ -338,8 +355,11 @@ export function linkFindingMessage({
     stub,
     shortcode,
     declared,
+    problems,
 }) {
     switch (reason) {
+        case "invalid-attributes":
+            return `wikilink [[${target}]] has invalid attributes: ${(problems ?? []).join("; ")}`;
         case "unlabelled":
             return unlabelledLinkMessage(target);
         case "not-an-address":
@@ -386,8 +406,6 @@ export function linkFindingMessage({
             return unresolvedAddressMessage(target);
         case "stub":
             return stubAddressMessage(target, stub);
-        case "gm":
-            return `address [[${target}]] names a GM-only note from a player-facing note`;
         case "no-content-index":
             return (
                 `address [[${target}]] names a package declared \`contentIndex: false\` — ` +
@@ -419,10 +437,11 @@ export function isSamePage({ target, anchor }) {
  * Read an operational link target in its enclosing Address context.
  * @param {string} inner - Lexical link contents.
  * @param {object} context - Builder defaults and type vocabulary.
+ * @param {string} [literal] - Whole matched link, including trailing attributes.
  * @returns {object} Typed target and diagnostic source spelling.
  */
-export function readWikilink(inner, context) {
-    const parsed = parseWikilink(inner);
+export function readWikilink(inner, context, literal = "") {
+    const parsed = parseWikilink(inner, literal);
     const rawTarget = parsed.target;
     if (!rawTarget) return { ...parsed, rawTarget, target: { kind: "same-page" } };
     const target = parseAddress(rawTarget, context);
@@ -433,3 +452,41 @@ export function readWikilink(inner, context) {
             { ...parsed, rawTarget, target: { kind: "literal", text: rawTarget }, problem: target }
         :   { ...parsed, rawTarget, target };
 }
+
+/** Whether the actual referenced destination needs spoiler presentation.
+ * @param {object} destination - Resolved note metadata.
+ * @param {string} [anchor] - Referenced prose anchor.
+ * @returns {boolean} Whole-note or section audience.
+ */
+export function secretDestination(destination, anchor = "") {
+    return Boolean(
+        destination?.gm ||
+        isGmNote(destination?.fm ?? destination) ||
+        (anchor && destination?.noteAnchors?.some((one) => one.slug === anchor && one.secret)),
+    );
+}
+
+/** Apply destination-derived presentation without changing its address.
+ * @param {string} reference - Rendered reference Markdown.
+ * @param {object} parsed - Shared parsed wikilink.
+ * @param {object} destination - Resolved target metadata.
+ * @returns {string} Inline spoiler or visible reference.
+ */
+export function presentWikilink(reference, parsed, destination) {
+    const attrs = parsed.attributes;
+    const classes = (attrs?.classes ?? []).filter((value) => value !== "show");
+    if (
+        !attrs?.classes.includes("show") &&
+        secretDestination(destination, parsed.anchor) &&
+        !classes.includes("secret")
+    )
+        classes.push("secret");
+    const fields = [
+        attrs?.id ? `#${attrs.id}` : "",
+        ...classes.map((value) => `.${value}`),
+        ...Object.entries(attrs?.values ?? {}).map(
+            ([key, value]) => `${key}="${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`,
+        ),
+    ].filter(Boolean);
+    return fields.length ? `[${reference}]{${fields.join(" ")}}` : reference;
+}

package/engine/wikilinks.mjs

@@ -27,7 +27,7 @@
 
 import { resolveShortcodeReference } from "./shortcode-references.mjs";
 
-import { readWikilink } from "./wikilink-syntax.mjs";
+import { presentWikilink, readWikilink } from "./wikilink-syntax.mjs";
 import crypto from "crypto";
 
 import { compendiumUuid, ITEM_PACK, packForType, pageUuid, PACK_BY_TYPE } from "./ids.mjs";
@@ -407,15 +407,29 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index, cap
     // one capture group. It is what makes two identical unresolved links on
     // one note tellable apart, and a position reportable at all.
     const out = replaceOutsideCode(markdown, WIKILINK, (all, rawInner, offset) => {
-        const parsed = readWikilink(rawInner, {
-            package: index.contentPackage,
-            system: "note",
-            types: index.types,
-            packages: index.packages,
-            noIndexPackages: index.noIndexPackages,
-        });
+        const parsed = readWikilink(
+            rawInner,
+            {
+                package: index.contentPackage,
+                system: "note",
+                types: index.types,
+                packages: index.packages,
+                noIndexPackages: index.noIndexPackages,
+            },
+            all,
+        );
         const target = parsed.rawTarget;
         const slug = parsed.anchor || null;
+        if (parsed.attributes?.problems.length) {
+            unresolved.push({
+                link: all,
+                target,
+                offset,
+                reason: "invalid-attributes",
+                problems: parsed.attributes.problems,
+            });
+            return unresolvedLink(authoredLabel(parsed) ?? target, target);
+        }
 
         // **Every link carries a label**. Without one there is nothing
         // to resolve against: a shortcode is an address rather than prose, so
@@ -512,7 +526,11 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index, cap
             if (hit) {
                 const uuid = slug ? hit.anchors?.[slug] : hit.uuid;
                 if (uuid) {
-                    return `@UUID[${uuid}]{${text || hit.name || target}}`;
+                    return presentWikilink(
+                        `@UUID[${uuid}]{${text || hit.name || target}}`,
+                        parsed,
+                        hit,
+                    );
                 }
                 unresolved.push({
                     link: all,
@@ -559,7 +577,7 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index, cap
         const entryUuid = itemDoc ? addresses.docUuid : addresses.uuid;
         // The target has no single Foundry document. Its address is real, but
         // a compendium has nothing to open, so the reader gets the label.
-        if (entryUuid === undefined) return text;
+        if (entryUuid === undefined) return presentWikilink(text, parsed, doc);
         const entryId = itemDoc ? itemDocEntryId(doc.id) : doc.id;
         const isJournal = itemDoc || packForType(doc.type).docType === "JournalEntry";
         // A JournalEntry link opens a journal — at its first page, or at the
@@ -614,7 +632,7 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index, cap
         // Presentation only — the UUID above is unchanged, and a
         // `[[#slug]]` self-link is not marked because the reader is already in
         // the note it would be telling them about.
-        return doc.draft ? draftLink(link) : link;
+        return presentWikilink(doc.draft ? draftLink(link) : link, parsed, doc);
     });
 
     return { markdown: out, unresolved };

package/engine/yaml-lint.mjs

@@ -29,6 +29,7 @@
 import { execFileSync } from "node:child_process";
 import fs from "node:fs";
 import path from "node:path";
+import { splitFrontmatter } from "./diagnostics.mjs";
 
 /** File extensions that carry YAML, either wholly or in a frontmatter fence. */
 export const YAML_GLOBS = Object.freeze(["*.md", "*.yaml", "*.yml"]);
@@ -42,9 +43,6 @@ export const YAML_GLOBS = Object.freeze(["*.md", "*.yaml", "*.yml"]);
  */
 const ALWAYS_SKIP = Object.freeze([".git/", ".claude/"]);
 
-/** A markdown file's leading frontmatter fence. Mirrors `parseMarkdownFile`. */
-const FENCE = /^---\n([\s\S]*?)\n---/;
-
 /**
  * Present a markdown file to ESLint as the YAML it begins with.
  *
@@ -68,8 +66,8 @@ export const frontmatterProcessor = {
     // container file. Nothing is gained by claiming support for it.
     supportsAutofix: false,
     preprocess(text) {
-        const fence = FENCE.exec(text);
-        return fence ? [{ text: fence[1], filename: "0.yaml" }] : [];
+        const fence = splitFrontmatter(text);
+        return fence ? [{ text: fence.yaml, filename: "0.yaml" }] : [];
     },
     postprocess(messages) {
         return (messages[0] ?? []).map((message) => ({

package/hugo-theme/layouts/partials/footer.html

@@ -27,3 +27,5 @@ document.querySelector('.nav-toggle')?.addEventListener('click', function() {
   this.classList.toggle('open');
 });
 </script>
+
+<script src="{{ "js/inline-spoilers.js" | relURL }}" defer></script>

package/hugo-theme/static/css/style.css

@@ -86,6 +86,10 @@ body {
   -webkit-font-smoothing: antialiased;
 }
 
+.name {
+  font-weight: 700;
+}
+
 a {
   color: var(--accent);
   text-decoration: none;
@@ -2988,3 +2992,19 @@ summary.info-sidebar-title::after {
 .single-content .alert-warning {
   --pb-alert-color: #d29922;
 }
+
+/* Inline spoiler controls remain inline, with links outside the button. */
+[data-inline-secret] .inline-secret-content[hidden] { display: none !important; }
+.inline-secret-toggle {
+    display: inline;
+    padding: 0.05em 0.35em;
+    border: 1px solid currentColor;
+    border-radius: 0.2em;
+    color: inherit;
+    background: transparent;
+    font: inherit;
+    font-size: 0.85em;
+    cursor: pointer;
+}
+.inline-secret-toggle:focus-visible { outline: 2px solid currentColor; outline-offset: 2px; }
+.inline-secret-content { margin-inline-start: 0.25em; }

package/hugo-theme/static/js/inline-spoilers.js

@@ -0,0 +1,23 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+// A native button provides pointer, Enter and Space activation without taking
+// keyboard events away from links within the independently revealed content.
+document.addEventListener("click", (event) => {
+    const button = event.target.closest?.(".inline-secret-toggle");
+    if (!button) return;
+    const wrapper = button.parentElement;
+    const content = button.nextElementSibling;
+    if (!wrapper?.hasAttribute("data-inline-secret") || !content?.classList.contains("inline-secret-content")) return;
+    const expanded = button.getAttribute("aria-expanded") !== "true";
+    if (!expanded && content.contains(document.activeElement)) button.focus();
+    content.hidden = !expanded;
+    button.setAttribute("aria-expanded", String(expanded));
+    const label = expanded ? "Hide spoiler" : "Show spoiler";
+    button.setAttribute("aria-label", label);
+    button.textContent = label;
+});

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "23.9.0",
+    "version": "23.11.0",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",