@heroiclands/package-build 22.20.0 → 22.22.0

package/types/engine/base-styles.d.mts

@@ -0,0 +1,93 @@
+/**
+ * The cascade layer the sheet loads into, per package kind.
+ *
+ * Foundry declares its layer order in `css/foundry2.css`, ending
+ * `… layouts, system, modules, exceptions` — the eighth and ninth being, by its
+ * own comments, default game system styles and default module styles. That is
+ * what this sheet is, so it takes the layer its kind is given and is therefore
+ * the weakest thing a package can load:
+ *
+ * - **An unlayered package sheet beats it**, because an unlayered rule beats
+ *   every layered one whatever its specificity.
+ * - **A package sheet naming any other layer beats it too**, because a layer
+ *   Foundry's order does not mention is appended after the ones it does.
+ *
+ * So a package overrides the base sheet from its own, whichever way it declares
+ * one, and the override needs no `!important` and no specificity contest.
+ *
+ * @param {"system"|"module"} artifact - Which artifact is shipped.
+ * @returns {string} The layer name.
+ */
+export function baseStyleLayer(artifact: "system" | "module"): string;
+/**
+ * The manifest `styles` entry for the base sheet.
+ *
+ * Foundry's `styles` is an array of `{layer?, src}`, and a bare string is
+ * migrated into that shape on read, so the object form is written directly.
+ *
+ * @param {"system"|"module"} artifact - Which artifact is shipped.
+ * @returns {{src: string, layer: string}} The entry.
+ */
+export function baseStyleEntry(artifact: "system" | "module"): {
+    src: string;
+    layer: string;
+};
+/**
+ * The absolute path of the sheet as installed, so the stage can copy it.
+ *
+ * Resolved against this module rather than against the consumer's working
+ * directory, because the file belongs to this package and arrives through
+ * `node_modules`.
+ *
+ * @returns {string} Absolute path of the shipped stylesheet.
+ */
+export function baseStylesheetSource(): string;
+/**
+ * The `[source, destination]` pair that stages the sheet.
+ *
+ * The destination is relative, in the same spelling the repository's own asset
+ * table uses, so the caller resolves both against the repository root exactly
+ * as it resolves every other entry.
+ *
+ * @param {string} stageDir - The configured stage directory, relative to the
+ *   repository root.
+ * @returns {[string, string]} The pair, for `stageAssets`.
+ */
+export function baseStyleStageEntry(stageDir: string): [string, string];
+/**
+ * The manifest's `styles`, with the base sheet named first.
+ *
+ * **First rather than last**, because `styles` is load order: a package's own
+ * sheet has to be read after the base one for an override written at equal
+ * specificity in an equal layer to take. The cascade layer makes the override
+ * work anyway, and the order makes it work for the right reason.
+ *
+ * A declared entry addressing the same file is not duplicated — a repository
+ * that named the staged path itself gets one entry, keeping whatever layer it
+ * chose, so declaring it is a way of placing it rather than an error.
+ *
+ * @param {object} options
+ * @param {unknown} [options.declared] - The declared `styles`, whatever shape
+ *   it was written in; anything that is not a list is returned untouched.
+ * @param {"system"|"module"} options.artifact - Which artifact is shipped.
+ * @param {boolean} [options.enabled] - Whether the package takes the base
+ *   sheet. `false` returns the declared list unchanged.
+ * @returns {unknown} The `styles` to emit, or `undefined` when there is
+ *   nothing to emit at all.
+ */
+export function withBaseStyle({ declared, artifact, enabled }: {
+    declared?: unknown;
+    artifact: "system" | "module";
+    enabled?: boolean | undefined;
+}): unknown;
+/**
+ * Where the shipped sheet lands inside the staged package.
+ *
+ * Under `styles/` beside a package's own sheet, and named for the toolchain so
+ * nothing a repository writes can collide with it. The path is relative to the
+ * staged package root, which is what both the stage entry and the manifest's
+ * `styles` are addressed in.
+ *
+ * @type {string}
+ */
+export const BASE_STYLESHEET_DEST: string;

package/types/engine/content-blocks.d.mts

@@ -0,0 +1,87 @@
+/**
+ * Find named blocks, leaving code examples alone.
+ *
+ * A block reaches `blocks` only when it is well formed and closed; everything
+ * else is a finding, and the surrounding blocks are unaffected.
+ *
+ * @param {string} source - Markdown that may contain named blocks.
+ * @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: string): {
+    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;
+    }>;
+};
+/**
+ * Render named blocks for one publishing surface.
+ *
+ * `foundry` emits a `<section>` whose heading is its first line; `web` emits a
+ * `<details>` the reader opens. Neither carries an inline `style`.
+ *
+ * The body is left as Markdown between the wrapper's tags, each separated from
+ * its tag by a blank line — see the module docs for why that is what lets the
+ * surrounding render treat the body as real content rather than an opaque
+ * fragment.
+ *
+ * A finding does not stop the well-formed blocks around it from rendering.
+ *
+ * @param {string} source - Markdown containing named blocks.
+ * @param {"foundry"|"web"} target - Publishing surface.
+ * @returns {{markdown: string, errors: Array<{line: number, column: number, message: string}>}}
+ */
+export function renderBlocks(source: string, target: "foundry" | "web"): {
+    markdown: string;
+    errors: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+};
+/**
+ * Wrap each withheld section in the disclosure a `secret` block renders as.
+ *
+ * The section's own Markdown is left as Markdown, with a blank line either side
+ * of it, so the page's renderer still reads it: the heading keeps its id, the
+ * prose keeps its links, and only the disclosure around them is written as HTML.
+ *
+ * **A spoiler, not access control.** The section is in the published page, so a
+ * reader who opens the element or reads the source reads it. Foundry is the one
+ * surface that withholds anything.
+ *
+ * @param {string} source - A page's Markdown, headings intact.
+ * @returns {string} The same Markdown, each withheld section inside a
+ *   `<details>`.
+ */
+export function renderWithheldSections(source: string): string;
+/** The blocks an author may open, with the heading each takes by default. */
+export const BLOCK_NAMES: Readonly<{
+    info: "Info";
+    secret: "Secret";
+    warn: "Warn";
+}>;
+/**
+ * Blocks that may hold another named block.
+ *
+ * A box inside a GM-only section is a real thing to write — the section is a
+ * container for whatever the GM reads, boxes included — so a `secret` holds one
+ * and the box stays inside it. A box inside a box is noise, so `info` and `warn`
+ * hold no named block and a second opener inside one is a finding.
+ *
+ * Exported because a renderer has to know it: the body of a container is read
+ * for blocks of its own, and the body of a box is not.
+ *
+ * @type {readonly string[]}
+ */
+export const BLOCK_CONTAINERS: readonly string[];

package/types/engine/content-captions.d.mts

@@ -27,7 +27,20 @@ export function scanCaptions(source: string): {
         message: string;
     }>;
 };
-/** Render captioned blocks as HTML, leaving other Markdown untouched. */
+/**
+ * Render captioned blocks as HTML, leaving other Markdown untouched.
+ *
+ * A code, table or prose caption's block is left as Markdown inside the
+ * wrapper, blank-line separated from its tags exactly as
+ * {@link module:engine/content-blocks.renderBlocks} leaves a named block's
+ * body — so the surrounding render sees it as part of its own document and a
+ * footnote reference inside it resolves against the note's own definitions.
+ *
+ * A figure's block is still rendered here, because its `<figcaption>` has to
+ * be stripped from HTML this pass controls directly; the surrounding render
+ * never sees it as Markdown, so a footnote reference inside a figure caption
+ * is not resolved, the same gap a block's own title carries.
+ */
 export function renderCaptionBlocks(source: any, renderMarkdown: ((src: string, env?: import("markdown-it").Env) => string) | undefined, numbers: any): {
     markdown: any;
     errors: {

package/types/engine/content-footnotes.d.mts

@@ -8,3 +8,76 @@ export function separateFootnotes(source: string): {
     markdown: string;
     definitions: string;
 };
+/**
+ * A footnote definition written inside a list item or a block quote, where
+ * the web and Foundry can resolve it but the book drops it silently.
+ *
+ * A definition inside a table cell is not reported here: a table cell is
+ * inline content, so `[^id]:` there is never recognised as a definition on
+ * any surface and simply prints as written — the reference it was meant to
+ * answer is what {@link unresolvedFootnoteReferences} reports.
+ *
+ * @param {string} source - A note's markdown body.
+ * @returns {Array<{line: number, column: number, label: string, message: string}>}
+ */
+export function misplacedFootnoteDefinitions(source: string): Array<{
+    line: number;
+    column: number;
+    label: string;
+    message: string;
+}>;
+/**
+ * A footnote reference with no top-level definition to resolve against.
+ *
+ * Covers both commoner slips alike: a label never defined at all, and one
+ * "defined" only inside a table cell, which is inline content and never
+ * registers as a definition on any surface. A label misplaced in a list or a
+ * block quote is excluded — {@link misplacedFootnoteDefinitions} already
+ * reports that mistake at the definition's own line, and reporting it again
+ * at the reference would say the same thing twice.
+ *
+ * @param {string} source - A note's markdown body.
+ * @param {string} [definitions] - Its top-level definitions, when a caller
+ *   already extracted them with {@link separateFootnotes}. Derived from
+ *   `source` when omitted; a caller already holding both passes its own
+ *   extraction instead, so the two cannot disagree about what is defined.
+ * @returns {Array<{line: number, column: number, message: string}>}
+ */
+export function unresolvedFootnoteReferences(source: string, definitions?: string): Array<{
+    line: number;
+    column: number;
+    message: string;
+}>;
+/**
+ * A top-level footnote definition no reference anywhere in the note uses.
+ *
+ * `separateFootnotes` lifts it out correctly, nothing resolves against it,
+ * and the paragraph it held vanishes from every surface with the build
+ * exiting 0 — a dropped paragraph is not something a reader can notice is
+ * missing, so it is an error here rather than a warning, the same severity
+ * every other silent loss this pass catches already carries. A note mid-edit,
+ * with the reference already deleted and the definition not yet followed, is
+ * exactly the case this refuses — which is the point: the alternative is
+ * shipping it.
+ *
+ * @param {string} source - A note's markdown body.
+ * @returns {Array<{line: number, column: number, message: string}>}
+ */
+export function unusedFootnoteDefinitions(source: string): Array<{
+    line: number;
+    column: number;
+    message: string;
+}>;
+/**
+ * Every footnote placement finding for one note body — the union
+ * {@link misplacedFootnoteDefinitions}, {@link unresolvedFootnoteReferences}
+ * and {@link unusedFootnoteDefinitions} report, in document order.
+ *
+ * @param {string} source - A note's markdown body.
+ * @returns {Array<{line: number, column: number, message: string}>}
+ */
+export function footnoteFindings(source: string): Array<{
+    line: number;
+    column: number;
+    message: string;
+}>;

package/types/engine/content-format-check.d.mts

@@ -180,12 +180,14 @@ export function checkDeclaredFields({ format, itemFields, system, severity }: {
 /**
  * Top-level keys the format names as the note's own, whatever its type.
  *
- * Top level is otherwise **open** — an unrecognised key there is a Hugo or
- * theme parameter this build has no standing to refuse — so this set exists
- * only to keep a note's own identity fields from being mistaken for a
- * misplaced `data` property where the two share a name. `type` and `subType`
- * are the pair that matters: several mapping tables name `subType` as a shared
- * source, and it is authored at top level by design.
+ * The top-level vocabulary itself, read rather than restated: this set exists
+ * to keep a note's own identity fields from being mistaken for a misplaced
+ * `data` property where the two share a name, and the keys that are a note's
+ * own are exactly the ones the region declares. `type` and `subType` are the
+ * pair that matters — several mapping tables name `subType` as a shared source,
+ * and it is authored at top level by design. A key the region does *not*
+ * declare, such as `id` beside `data.id`, is reported as the misplaced `data`
+ * property it is.
  *
  * @type {ReadonlySet<string>}
  */

package/types/engine/content-tables.d.mts

@@ -1,13 +1,21 @@
 /**
- * Replace prepared SQL fences with Markdown tables while retaining source lines.
- * Query execution happens in the asynchronous SQL preparation pass.
+ * Replace prepared SQL fences and page lists with Markdown while retaining
+ * source lines.
+ *
+ * Both directives read the content index, so both are answered before this
+ * pass runs — query execution in the asynchronous SQL preparation pass, page
+ * lists in {@link module:engine/page-lists.preparePageLists} — and each is
+ * looked up by the ordinal of its own kind of fence within the body.
+ *
  * @param {string} markdown - The authored body.
- * @param {{source?: string, sqlTables?: object[]}} [context] - Prepared results.
+ * @param {{source?: string, sqlTables?: object[], pageLists?: object[]}} [context] -
+ *   Prepared results.
  * @returns {{markdown: string, errors: object[], warnings: object[], lineMap: object[]}}
  */
-export function expandContentTables(markdown: string, { source, sqlTables }?: {
+export function expandContentTables(markdown: string, { source, sqlTables, pageLists }?: {
     source?: string;
     sqlTables?: object[];
+    pageLists?: object[];
 }): {
     markdown: string;
     errors: object[];

package/types/engine/content-tasklists.d.mts

@@ -0,0 +1,72 @@
+/**
+ * What a note opening a list item with `[ ]` or `[x]` is told.
+ *
+ * @param {string} marker - The matched marker, as written.
+ * @returns {string} The message, unpunctuated at the end as a finding is.
+ */
+export function taskListMessage(marker: string): string;
+/**
+ * Every list item opened with `[ ]` or `[x]` in one note's body.
+ *
+ * @param {string} body - The note's markdown, without its frontmatter.
+ * @param {string} file - The note's path, for the finding.
+ * @param {object} [opts]
+ * @param {number} [opts.bodyLine=1] - The 1-based file line the body starts on.
+ * @param {number} [opts.bodyColumn=1] - The 1-based file column it starts at.
+ * @returns {Array<{file: string, line: number, column: number,
+ *   severity: "warning", message: string}>} One finding per item, in source
+ *   order.
+ */
+export function checkTaskLists(body: string, file: string, { bodyLine, bodyColumn }?: {
+    bodyLine?: number | undefined;
+    bodyColumn?: number | undefined;
+}): Array<{
+    file: string;
+    line: number;
+    column: number;
+    severity: "warning";
+    message: string;
+}>;
+/**
+ * Walk a content tree and report every list item opened with `[ ]` or `[x]`.
+ *
+ * The frontmatter fence is taken off first, so what is scanned is the body and
+ * the positions are still the file's. A file with no frontmatter is scanned
+ * whole: it is not a note, but a stray `.md` in the tree carrying the marker is
+ * the same problem for the same reason.
+ *
+ * A finding names its file **relative to the working directory**, which is
+ * where a reader is standing and what `formatDiagnostic` emits. The content
+ * root is where the walk starts, not what a path is measured from.
+ *
+ * @param {string} contentBase - Root of the content tree.
+ * @param {object} [opts]
+ * @param {readonly string[]} [opts.skipDirectories] - Directory names to ignore
+ *   in addition to the dot-directories always skipped.
+ * @returns {{findings: Array<{file: string, line: number, column: number,
+ *   severity: "warning", message: string}>, files: number}} The findings, and
+ *   how many files were read.
+ */
+export function lintContentTaskLists(contentBase: string, { skipDirectories }?: {
+    skipDirectories?: readonly string[] | undefined;
+}): {
+    findings: Array<{
+        file: string;
+        line: number;
+        column: number;
+        severity: "warning";
+        message: string;
+    }>;
+    files: number;
+};
+/**
+ * A list item's marker, immediately followed by `[ ]` or `[x]` and a space —
+ * bulleted (`-`, `*`, `+`) or ordered (`1.` or `1)`), at the start of a line.
+ *
+ * The leading indentation is a lookbehind rather than part of the match, so a
+ * nested item's finding points at the marker itself, not at the line's first
+ * column.
+ *
+ * @type {RegExp}
+ */
+export const TASK_LIST_MARKER: RegExp;

package/types/engine/extension-attributes.d.mts

@@ -2,9 +2,15 @@
  * Read the shared braced attribute grammar used by body extensions.
  * Callers validate which names and classes their extension understands.
  * @param {string} source - Text inside the braces.
+ * @param {object} [options={}]
+ * @param {RegExp} [options.idPattern=NAME] - What an `#id` may be named. A
+ *   construct whose id is published as an HTML `id` admits a digit first and
+ *   passes a looser pattern; the default is the pattern every other name takes.
  * @returns {{id: string, classes: string[], values: Record<string, string>, problems: string[]}}
  */
-export function parseExtensionAttributes(source: string): {
+export function parseExtensionAttributes(source: string, { idPattern }?: {
+    idPattern?: RegExp | undefined;
+}): {
     id: string;
     classes: string[];
     values: Record<string, string>;
@@ -12,3 +18,18 @@ export function parseExtensionAttributes(source: string): {
 };
 /** A Boolean attribute is spelled exactly `true` or `false`. */
 export function booleanAttribute(value: any, key: any): boolean;
+/**
+ * The attribute keys no construct writes onto an element.
+ *
+ * `id=` and `class=` are refused in favour of `#id` and `.class`, which the
+ * grammar already states; a key beginning `on` is an event handler, and nothing
+ * authored in a note becomes code on a published page.
+ *
+ * Shared by every construct that writes an author's attributes onto an element,
+ * because a refusal that held on one and not the next would be the hole the
+ * other construct is checked for.
+ *
+ * @param {Record<string, string>} values - The `key=value` attributes parsed.
+ * @returns {string[]} One message per refused key, in the order written.
+ */
+export function refusedAttributes(values: Record<string, string>): string[];

package/types/engine/frontmatter.d.mts

@@ -137,7 +137,7 @@ export function resolveRelation(fm: object, ctx?: string): Record<string, string
  *
  * @param {object} fm - The item frontmatter.
  * @param {string} [ctx] - Optional label for the error (defaults to the item's
- *   title/name, else "item").
+ *   display name, else "item").
  * @returns {string} The declared subType.
  * @throws {Error} When `subType` is missing or blank.
  */

package/types/engine/heading-attributes.d.mts

@@ -0,0 +1,174 @@
+/**
+ * Read a heading's text and the attribute block it may end with.
+ *
+ * A suffix that is not an attribute block — a set written in braces, a die
+ * expression — is left in the text and reported, so no surface silently prints
+ * a heading with words missing and no author is told to fix nothing.
+ *
+ * **One mistake draws one finding.** Braces holding nothing the grammar
+ * recognises are reported once, naming the braces: an author who wrote
+ * `{a, b}` meant no attribute block at all, and a complaint per fragment inside
+ * it says the same thing twice in words that name neither the heading nor the
+ * fix. Braces that *are* an attribute block, carrying one bad attribute beside
+ * good ones, relay the grammar's own complaint about that attribute.
+ *
+ * @param {string} heading - A heading's text, hashes already removed.
+ * @returns {{text: string, id: string, classes: string[],
+ *   values: Record<string, string>, problems: string[], braces: boolean}}
+ *   `text` is what a surface sets, `braces` whether a suffix was there at all.
+ */
+export function splitHeadingAttributes(heading: string): {
+    text: string;
+    id: string;
+    classes: string[];
+    values: Record<string, string>;
+    problems: string[];
+    braces: boolean;
+};
+/**
+ * Whether a heading opens a journal page.
+ *
+ * A Foundry UUID addresses a page and nothing smaller, so a section a link can
+ * reach has to be one: a top-level heading starts a page, and so does any
+ * heading that names an anchor. {@link module:engine/journals.splitPages}
+ * decides *where* a page begins — a captioned heading and a heading inside a
+ * fence or a named block are its business — and asks this which headings are
+ * eligible, so no caller re-decides it.
+ *
+ * @param {{level: number, id: string}} heading - From
+ *   {@link scanHeadingAttributes}, or any `{level, id}` pair.
+ * @returns {boolean} Whether the heading opens a page.
+ */
+export function opensPage({ level, id }: {
+    level: number;
+    id: string;
+}): boolean;
+/**
+ * Every heading in a body, with what its attribute block declares.
+ *
+ * Fenced code is skipped: `#` opens a comment in most of what gets fenced, and
+ * an example heading in a document is not a heading of it.
+ *
+ * @param {string} source - A note's markdown body.
+ * @param {number} [bodyLine=1] - The 1-based file line the body starts on, so a
+ *   finding lands where an editor can open it.
+ * @returns {{headings: Array<{level: number, line: number, text: string,
+ *   id: string, classes: string[], values: Record<string, string>}>,
+ *   errors: Array<{line: number, column: number, message: string}>}}
+ */
+export function scanHeadingAttributes(source: string, bodyLine?: number): {
+    headings: Array<{
+        level: number;
+        line: number;
+        text: string;
+        id: string;
+        classes: string[];
+        values: Record<string, string>;
+    }>;
+    errors: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+};
+/**
+ * A markdown-it plugin writing a heading's attribute block onto its element.
+ *
+ * The website's renderer reads the block itself, so the surfaces that use
+ * markdown-it read it here and publish the same `id`, the same classes and the
+ * same attributes — rather than typesetting the braces an author wrote.
+ *
+ * @param {object} md - A markdown-it instance.
+ * @returns {void}
+ */
+export function headingAttributesPlugin(md: object): void;
+/**
+ * Parse one line as a heading, and say whether it starts a journal page.
+ *
+ * The single reading of that rule. {@link module:engine/journals.splitPages}
+ * builds its pages from it; `scanBlocks` and `scanCaptions` refuse a heading
+ * that starts a page written where it cannot become one. All three ask this, so
+ * none of them can disagree about what a heading line means or about what starts
+ * a page — and the attribute block comes off here, so a class beside an anchor
+ * is not read as part of the anchor by any of them.
+ *
+ * @param {string} line - One line of a note's body.
+ * @returns {{level: number, text: string, id: string, classes: string[],
+ *   values: Record<string, string>, problems: string[], startsPage: boolean}|null}
+ *   `null` when the line is not a heading.
+ */
+export function parseHeadingLine(line: string): {
+    level: number;
+    text: string;
+    id: string;
+    classes: string[];
+    values: Record<string, string>;
+    problems: string[];
+    startsPage: boolean;
+} | null;
+/**
+ * Every heading that opens a journal page, by the line it sits on.
+ *
+ * The walk that decides it: fenced code holds no headings, a named block holds
+ * no page — the block is one passage of the page it is written in — and what is
+ * left is read by {@link opensPage}. {@link module:engine/journals.splitPages}
+ * builds the pages from this, and the passes that honour a class on a
+ * page-opening heading ask the same question of the same answer.
+ *
+ * A caption also opens a page, which is `splitPages`' business: a caption is
+ * found by the caption pass, and a heading it captions is listed here and
+ * dropped there.
+ *
+ * @param {string} source - A note's markdown body.
+ * @returns {Map<number, {level: number, line: number, text: string, id: string,
+ *   classes: string[], values: Record<string, string>}>} Keyed by 0-based line.
+ */
+export function pageOpenings(source: string): Map<number, {
+    level: number;
+    line: number;
+    text: string;
+    id: string;
+    classes: string[];
+    values: Record<string, string>;
+}>;
+/**
+ * The spans a `.secret` heading withholds, and the classes written where no
+ * surface can honour them.
+ *
+ * A span runs from its heading to the line before the next heading that opens a
+ * page, which is the stretch Foundry makes one page of. A `.secret` on a heading
+ * that opens no page covers no page, so no surface can withhold it: that is a
+ * finding at the heading's own line rather than a class quietly ignored.
+ *
+ * @param {string} source - A note's markdown body.
+ * @param {number} [bodyLine=1] - The 1-based file line the body starts on.
+ * @returns {{sections: Array<{start: number, end: number, heading: object}>,
+ *   errors: Array<{line: number, column: number, message: string}>}} `start` and
+ *   `end` are 0-based line indexes, `end` exclusive.
+ */
+export function withheldSections(source: string, bodyLine?: number): {
+    sections: Array<{
+        start: number;
+        end: number;
+        heading: object;
+    }>;
+    errors: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+};
+/**
+ * A heading line: its hashes and the text after them.
+ *
+ * Shared with every pass that has to find a heading before reading what it
+ * declares, so the passes cannot disagree about which lines are headings.
+ */
+export const HEADING_LINE: RegExp;
+/**
+ * The class that withholds a section from players.
+ *
+ * Written on the heading that opens the section, so the section stays linkable:
+ * secrecy is a property of the section, not of the name a link resolves to.
+ */
+export const WITHHELD_CLASS: "secret";

package/types/engine/helpers.d.mts

@@ -1,4 +1,4 @@
-/** Render a note body with Foundry's secret section markup. */
+/** Render a note body with Foundry's named-block markup. */
 export function renderFoundryMarkdown(body: any, captions: any, footnoteNumbers: any, docId: any): string;
 /**
  * Parses a markdown file with YAML frontmatter.
@@ -426,18 +426,21 @@ export function convertNoteWikilinks(body: string, { type, id, pack, docPack, in
     unresolved: Array<object>;
 };
 /**
- * Expand prepared SQL tables before resolving wikilinks in generated cells.
+ * Expand prepared SQL tables and page lists before resolving wikilinks in the
+ * links they generate.
  * @param {string} body - The note body.
- * @param {object} ctx - Source and prepared query results.
+ * @param {object} ctx - Source and prepared results.
  * @param {string} ctx.name - Name used in diagnostics.
  * @param {number} [ctx.bodyLine] - The first body line in the source file.
  * @param {object[]} [ctx.sqlTables] - Prepared SQL results in document order.
+ * @param {object[]} [ctx.pageLists] - Prepared page lists in document order.
  * @returns {{markdown: string, lineMap: Array<{line: number, generated: boolean}>}}
  */
-export function expandNoteTables(body: string, { name, bodyLine, sqlTables }: {
+export function expandNoteTables(body: string, { name, bodyLine, sqlTables, pageLists }: {
     name: string;
     bodyLine?: number | undefined;
     sqlTables?: object[] | undefined;
+    pageLists?: object[] | undefined;
 }): {
     markdown: string;
     lineMap: Array<{