@heroiclands/package-build 23.12.6 → 23.12.8

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

@@ -0,0 +1,226 @@
+/**
+ * The context a resolved configuration gives, and the maps an index holds.
+ *
+ * @param {{languages?: object, rootDir?: string}|undefined} config - The
+ *   resolved configuration.
+ * @param {Iterable<Record<string, any>>} [records] - The content index's
+ *   records, whose mapping notes give the maps. Without them no map is known.
+ * @returns {RunContext} Its languages, the faces installed where it sits, and
+ *   the maps. A fonts package that cannot be read gives no faces; a run naming
+ *   one is reported.
+ */
+export function runContext(config: {
+    languages?: object;
+    rootDir?: string;
+} | undefined, records?: Iterable<Record<string, any>>): RunContext;
+/**
+ * Find the spans, divs and poetry fences marked with `lang=`, `font=` or
+ * `map=`, and every fault in their markup and their text.
+ *
+ * @param {string} source - Authored Markdown: a note body, or a whole file
+ *   whose frontmatter is blanked.
+ * @param {RunContext} [ctx] - The configured languages, the installed faces
+ *   and the maps. Without them every `lang=` must be a tag, every face and
+ *   map is unknown, and only `mono`, `serif` and `sans` are fonts.
+ * @param {import("./content-session.mjs").ContentSyntax} [syntax] - Session
+ *   scanner projections, so the source's spans and blocks are scanned once.
+ * @returns {{runs: Run[], errors: Array<{line: number, column: number, message: string}>, warnings: Array<{line: number, column: number, message: string}>}}
+ *   The runs in source order, and each finding at its 1-based position. A
+ *   warning is a `lang=` read as a tag that sits within one edit of a
+ *   declared name.
+ */
+export function scanRuns(source: string, ctx?: RunContext, syntax?: import("./content-session.mjs").ContentSyntax): {
+    runs: Run[];
+    errors: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+    warnings: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+};
+/**
+ * Rewrite text marked with `lang=`, `font=` and `map=` into the plain span,
+ * div and poetry grammar the rest of each chain renders, one line for one line.
+ *
+ * - **The map, if any, is applied first.** Characters Markdown would read are
+ *   then backslash-escaped, so they reach every later pass as characters.
+ * - **The construct carries** the language's tag as `lang`, the face's class
+ *   (with `script`, and `script-block` on a div) or the generic family's
+ *   class. On the site, a face's construct also carries
+ *   `data-pagefind-ignore`, since site search cannot read its code points;
+ *   Foundry and the book receive no search marker.
+ * - **A div or fence in a right-to-left face** carries `dir=rtl`. No direction
+ *   mark, `<bdo>` or `<bdi>` is ever written: the code points carry their own
+ *   direction.
+ *
+ * A run with a finding is left as written; {@link scanRuns} reports it.
+ *
+ * @param {string} source - Authored Markdown: a note body.
+ * @param {RunContext} [ctx] - The configured languages, faces and maps.
+ * @param {import("./content-session.mjs").ContentSyntax} [syntax] - Session
+ *   scanner projections.
+ * @param {{target?: "site"|"foundry"|"book"}} [options] - The target the
+ *   Markdown is rendered for; only `site` writes the search marker.
+ * @returns {{markdown: string, errors: Array<{line: number, column: number, message: string}>}}
+ *   The rewritten Markdown, and the findings of {@link scanRuns}.
+ */
+export function renderRuns(source: string, ctx?: RunContext, syntax?: import("./content-session.mjs").ContentSyntax, options?: {
+    target?: "site" | "foundry" | "book";
+}): {
+    markdown: string;
+    errors: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+};
+/** The keys this module reads, which no construct passes through as written. */
+export const RUN_KEYS: readonly string[];
+/** The generic families `font=` may name, each with the class that sets it. */
+export const GENERIC_FONTS: Readonly<{
+    mono: "font-mono";
+    serif: "font-serif";
+    sans: "font-sans";
+}>;
+/**
+ * One marked construct, with what rendering it needs beside its {@link Run}.
+ */
+export type RunDetail = {
+    /**
+     * - The run.
+     */
+    run: Run;
+    /**
+     * -
+     * What the construct carries besides the run keys.
+     */
+    own: {
+        id: string;
+        classes: string[];
+        values: Array<[string, string]>;
+    };
+    /**
+     * - The run keys it states itself.
+     */
+    keys: Record<string, string>;
+    /**
+     * - Whether its text is set.
+     */
+    plain: boolean;
+    /**
+     * - Its face.
+     */
+    face: import("./script-fonts.mjs").Face | undefined;
+    /**
+     * - Its generic family's class.
+     */
+    generic: string | undefined;
+    /**
+     * - Its map.
+     */
+    textMap: import("./text-maps.mjs").TextMap | undefined;
+    /**
+     * - Its map,
+     * face and lexicon, which its text is set by.
+     */
+    mapping: import("./map-lexicon.mjs").Mapping | undefined;
+    /**
+     * - The marked spans inside it.
+     */
+    holes: Map<number, number>;
+    /**
+     * - A div's or fence's body, as
+     * offsets: the first body line's start to the end of the last.
+     */
+    body: [number, number] | undefined;
+    /**
+     * - A span's offset of its closing `]`.
+     */
+    contentEnd: number | undefined;
+};
+/**
+ * What a run is checked against.
+ */
+export type RunContext = {
+    /**
+     * - The
+     * configured languages.
+     */
+    languages?: Readonly<Record<string, {
+        tag: string;
+    }>> | undefined;
+    /**
+     * -
+     * The installed faces by slug, from
+     * {@link module :engine/script-fonts.resolveScriptFonts}.
+     */
+    faces?: ReadonlyMap<string, import("./script-fonts.mjs").Face> | undefined;
+    /**
+     * -
+     * The mapping notes' maps by name, from
+     * {@link module :engine/text-maps.mapsFromRecords}.
+     */
+    maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap> | undefined;
+    /**
+     * -
+     * Each configured language's lexicon by name, from
+     * {@link module :engine/map-lexicon.lexiconsFromRecords}.
+     */
+    lexicons?: ReadonlyMap<string, import("./map-lexicon.mjs").Lexicon> | undefined;
+    /**
+     * -
+     * What each configured language's mapped runs are checked against, from
+     * {@link module :engine/run-words.wordBooksFromRecords}.
+     */
+    wordBooks?: ReadonlyMap<string, import("./run-words.mjs").WordBook> | undefined;
+};
+/**
+ * One span, div or poetry fence carrying `lang=`, `font=` or `map=`. Its
+ * `lang`, `font` and `map` are the ones it is set with: its own, else the
+ * innermost div or fence around it that states one.
+ */
+export type Run = {
+    /**
+     * - Which construct.
+     */
+    kind: "span" | "block" | "poetry";
+    /**
+     * - The language as written.
+     */
+    lang: string | undefined;
+    /**
+     * - The BCP 47 tag it resolves to; `undefined`
+     * when it resolves to none.
+     */
+    tag: string | undefined;
+    /**
+     * - The font as written.
+     */
+    font: string | undefined;
+    /**
+     * - The map as written.
+     */
+    map: string | undefined;
+    /**
+     * - 1-based line of the construct's opening.
+     */
+    line: number;
+    /**
+     * - 1-based UTF-16 column of its opening.
+     */
+    column: number;
+    /**
+     * - A span's offset of `[`; a div's or fence's
+     * 0-based opening line.
+     */
+    start: number;
+    /**
+     * - A span's offset past its attributes; a div's or
+     * fence's 0-based closing line.
+     */
+    end: number;
+};

package/types/engine/data-keys.d.mts

@@ -5,7 +5,7 @@
  * @property {string} name - The key as an author writes it.
  * @property {string} [kind] - Its value's shape: `string`, `date`, `number`,
  *   `integer`, `boolean`, `address`, `list`, `map`, `scalar-or-map`,
- *   `string-or-list`, or `string-list-or-map` — see {@link fitsKind}. Absent, the check
+ *   `string-or-list`, `string-list-or-map` or `list-or-map` — see {@link fitsKind}. Absent, the check
  *   makes no claim about the value.
  * @property {readonly string[]} [allowed] - The closed set a present value is
  *   one of, where the key takes a fixed word.
@@ -97,7 +97,7 @@ export type InnerKeySpec = {
     /**
      * - Its value's shape: `string`, `date`, `number`,
      * `integer`, `boolean`, `address`, `list`, `map`, `scalar-or-map`,
-     * `string-or-list`, or `string-list-or-map` — see {@link fitsKind}. Absent, the check
+     * `string-or-list`, `string-list-or-map` or `list-or-map` — see {@link fitsKind}. Absent, the check
      * makes no claim about the value.
      */
     kind?: string | undefined;

package/types/engine/dictionary-rows.d.mts

@@ -1,3 +1,18 @@
+/**
+ * A noun's stated plural, or the first literal ending replacement that fits.
+ *
+ * @param {{form: string, class?: unknown, plural?: unknown}} word - A word of
+ *   `data.words`.
+ * @param {Record<string, any>|undefined} grammar - Its language's
+ *   `data.grammar`.
+ * @returns {string|null} The plural, or `null` for a word that is no noun or
+ *   that no rule fits.
+ */
+export function pluralOf(word: {
+    form: string;
+    class?: unknown;
+    plural?: unknown;
+}, grammar: Record<string, any> | undefined): string | null;
 /**
  * The stable prose anchor of a word in one language's dictionary. The exact
  * language and NFC form identify it, including case and accents.

package/types/engine/helpers.d.mts

@@ -10,12 +10,16 @@
  * @param {(address: string) => string|undefined} [resolveRole] - From a
  *   picture's address to the role its asset declares — see
  *   {@link module:engine/content-figures.scanFigures}.
+ * @param {import("./content-scripts.mjs").RunContext} [runs] - The package's
+ *   languages, faces and maps. Given, text marked with `lang=`, `font=` and
+ *   `map=` is rewritten first, so it is tagged for its language, mapped and
+ *   set in its font.
  * @returns {string} The rendered HTML.
  */
 export function renderFoundryMarkdown(body: string, figures?: Array<{
     id: string;
     label: string;
-}>, footnoteNumbers?: Map<string, number>, docId?: string, resolveRole?: (address: string) => string | undefined): string;
+}>, footnoteNumbers?: Map<string, number>, docId?: string, resolveRole?: (address: string) => string | undefined, runs?: import("./content-scripts.mjs").RunContext): string;
 /**
  * Parses a markdown file with LF or CRLF YAML frontmatter delimiters.
  *

package/types/engine/journals.d.mts

@@ -134,13 +134,15 @@ export function journalPageId(entryId: string, page: {
  *   carries its own figure already, from {@link splitPages}.
  * @param {(address: string) => string|undefined} [resolveRole] - See
  *   {@link splitPages}.
+ * @param {import("./content-scripts.mjs").RunContext} [runs] - The package's
+ *   languages, faces and maps — see {@link module:engine/helpers.renderFoundryMarkdown}.
  * @returns {Array<{_id: string, name: string, type: string,
  *   title: {show: boolean, level: number},
  *   text: {format: number, content: string}, _key: string,
  *   ownership?: {default: number}}>} The page documents, in order.
  * @throws {Error} When the note has no content at all, or repeats an anchor.
  */
-export function buildPages(rawPages: Array<object>, entryId: string, noteName: string, figures: Array<object>, resolveRole?: (address: string) => string | undefined): Array<{
+export function buildPages(rawPages: Array<object>, entryId: string, noteName: string, figures: Array<object>, resolveRole?: (address: string) => string | undefined, runs?: import("./content-scripts.mjs").RunContext): Array<{
     _id: string;
     name: string;
     type: string;
@@ -192,9 +194,11 @@ export function buildPages(rawPages: Array<object>, entryId: string, noteName: s
  *   name reads `Map 1` rather than `Figure 1` where it is due — see
  *   {@link module:engine/content-figures.scanFigures}.
  * @param {import("./content-session.mjs").ContentSyntax} [params.syntax] - Session scanner projections.
+ * @param {import("./content-scripts.mjs").RunContext} [params.runs] - The package's
+ *   languages, faces and maps — see {@link module:engine/helpers.renderFoundryMarkdown}.
  * @returns {object} The JournalEntry document, keyed for the pack.
  */
-export function buildJournalEntry({ id, name, markdown, leadName, folder, stats, infoboxes, notice, resolveRole, syntax, }: {
+export function buildJournalEntry({ id, name, markdown, leadName, folder, stats, infoboxes, notice, resolveRole, syntax, runs, }: {
     id: string;
     name: string;
     markdown: string;
@@ -209,6 +213,7 @@ export function buildJournalEntry({ id, name, markdown, leadName, folder, stats,
     notice?: string | undefined;
     resolveRole?: ((address: string) => string | undefined) | undefined;
     syntax?: import("./content-session.mjs").ContentSyntax | undefined;
+    runs?: import("./content-scripts.mjs").RunContext | undefined;
 }): object;
 /**
  * Journals pack compiler.

package/types/engine/language-data.d.mts

@@ -20,3 +20,5 @@ export function checkLanguageData(note: object, { index, types }?: {
     index?: object | undefined;
     types?: readonly string[] | undefined;
 }): object[];
+/** How a foreign row that its tongue's register does not bear out is reported. */
+export const FOREIGN_ROW_SEVERITY: "warning";

package/types/engine/language-tag.d.mts

@@ -0,0 +1,8 @@
+/**
+ * Whether a value is a BCP 47 language tag.
+ *
+ * @param {unknown} value - The value to test.
+ * @returns {boolean} Whether it is a well-formed tag with no repeated variant
+ *   or extension singleton.
+ */
+export function isLanguageTag(value: unknown): boolean;

package/types/engine/language-terms.d.mts

@@ -321,7 +321,8 @@ export const NEAR_NAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[]
 export const NAMING_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The six present persons of the one optional regular verb pattern, in
- * presentation order. Empty endings leave the citation form unchanged.
+ * presentation order. Each ending is added to the citation form, or takes the
+ * place of its closing `replaces`; an empty ending adds nothing.
  *
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */

package/types/engine/map-lexicon.d.mts

@@ -0,0 +1,274 @@
+/**
+ * Each configured language's lexicon, read from the language note its `note`
+ * names. A language with no `note`, or one naming no language note, has none.
+ *
+ * @param {Iterable<Record<string, any>>|undefined} records - Index records.
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
+ *   The resolved configuration.
+ * @returns {Map<string, Lexicon>} The lexicons by language name.
+ */
+export function lexiconsFromRecords(records: Iterable<Record<string, any>> | undefined, config?: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+}): Map<string, Lexicon>;
+/**
+ * The language note each configured language's `note` names, by language
+ * name. A language with no `note`, or one naming no language note, is absent.
+ *
+ * @param {Iterable<Record<string, any>>|undefined} records - Index records.
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
+ *   The resolved configuration.
+ * @returns {Map<string, Record<string, any>>} The records.
+ */
+export function languageRecordsByName(records: Iterable<Record<string, any>> | undefined, { languages, contentPackage }?: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+}): Map<string, Record<string, any>>;
+/**
+ * Each `languages.<name>.note` that names no language note, at its key.
+ *
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string, configFile?: string, configText?: string}} config -
+ *   The resolved configuration, and where it was read from.
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]} The findings.
+ */
+export function languageNoteFindings(config: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+    configFile?: string;
+    configText?: string;
+}, records: Iterable<Record<string, any>>): object[];
+/**
+ * A lookup of a word's native form under one map in one face: the form stated
+ * for the face, else the one stated for no face.
+ *
+ * @param {Lexicon|undefined} lexicon - The lexicon.
+ * @param {string} map - The map's name.
+ * @param {string|undefined} font - The face.
+ * @returns {((word: string) => string|undefined)|undefined} The lookup, or
+ *   `undefined` with no lexicon.
+ */
+export function nativeLookup(lexicon: Lexicon | undefined, map: string, font: string | undefined): ((word: string) => string | undefined) | undefined;
+/**
+ * What a run, a passage or a listing is mapped by.
+ *
+ * @typedef {object} Mapping
+ * @property {import("./text-maps.mjs").TextMap} map - The map.
+ * @property {string|undefined} font - The face, whose own rows come first.
+ * @property {((word: string) => string|undefined)|undefined} native - The
+ *   language's native forms under the map in the face.
+ */
+/**
+ * The one path from a map, a face and a language to what rewrites the text.
+ *
+ * @param {{maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>, lexicons?: ReadonlyMap<string, Lexicon>}} ctx -
+ *   The run context.
+ * @param {{map: string, font?: string, lang?: string}} keys - The map, the face
+ *   and the language.
+ * @returns {Mapping|undefined} The mapping, or `undefined` for an unknown map.
+ */
+export function mappingFor(ctx: {
+    maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>;
+    lexicons?: ReadonlyMap<string, Lexicon>;
+}, { map, font, lang }: {
+    map: string;
+    font?: string;
+    lang?: string;
+}): Mapping | undefined;
+/**
+ * Why a face is not one a map is for, or `undefined` where it is.
+ *
+ * @param {import("./text-maps.mjs").TextMap} map - The map.
+ * @param {string} font - The face's slug.
+ * @returns {string|undefined} The problem.
+ */
+export function fontProblem(map: import("./text-maps.mjs").TextMap, font: string): string | undefined;
+/**
+ * What is wrong with a capitalised word whose native form the rows cannot
+ * capitalise.
+ *
+ * @param {string} word - The word as written.
+ * @param {string} lower - The lowercase form the lexicon states.
+ * @param {string|undefined} lang - The language.
+ * @param {string} map - The map's name.
+ * @returns {string} The message.
+ */
+export function uncapitalisedMessage(word: string, lower: string, lang: string | undefined, map: string): string;
+/**
+ * Map a passage exactly as the build maps a run with the same keys.
+ *
+ * @param {object} ctx - The run context.
+ * @param {{map: string, font?: string, lang?: string}} keys - The map, the face
+ *   and the language.
+ * @param {string} text - The passage, with no escapes.
+ * @returns {{text: string}|{problem: string, about: string}} The mapped text, or the problem.
+ */
+export function transliterate(ctx: object, keys: {
+    map: string;
+    font?: string;
+    lang?: string;
+}, text: string): {
+    text: string;
+} | {
+    problem: string;
+    about: string;
+};
+/**
+ * Every word of a language's lexicon with its native form under a map: the
+ * stated exception, else the rows' spelling, each exactly as the build gives
+ * it.
+ *
+ * @param {object} ctx - The run context.
+ * @param {{lang: string, map: string, font?: string}} keys - The language, the
+ *   map and the face.
+ * @returns {{entries: Array<{form: string, native: string, exception: boolean, class: string|null, gloss: string|null}>}|{problem: string, about: string}}
+ *   The words in `data.words` order, or the problem.
+ */
+export function lexiconEntries(ctx: object, { lang, map, font }: {
+    lang: string;
+    map: string;
+    font?: string;
+}): {
+    entries: Array<{
+        form: string;
+        native: string;
+        exception: boolean;
+        class: string | null;
+        gloss: string | null;
+    }>;
+} | {
+    problem: string;
+    about: string;
+};
+/**
+ * Check a mapping note's `fonts` against the installed faces: an unknown face
+ * and a face listed twice, at the entry, and each code point a listed face
+ * lacks, at the row that writes it.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
+ * @param {{faces?: ReadonlyMap<string, import("./script-fonts.mjs").Face>, maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>}} ctx -
+ *   The run context.
+ * @returns {object[]} The findings.
+ */
+export function checkMapFonts(note: {
+    file: string;
+    raw?: string;
+    fm?: Record<string, any>;
+}, ctx: {
+    faces?: ReadonlyMap<string, import("./script-fonts.mjs").Face>;
+    maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>;
+}): object[];
+/**
+ * Check a language note's native forms against the maps and faces: an unknown
+ * map, a face the map is not for, a second form for one map and face, a form
+ * that states what the rows already give, and a code point a face it applies
+ * in does not draw. The shape of each entry is the data-key check's.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
+ * @param {{faces?: ReadonlyMap<string, import("./script-fonts.mjs").Face>, maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>}} ctx -
+ *   The run context.
+ * @returns {object[]} The findings.
+ */
+export function checkLexiconNatives(note: {
+    file: string;
+    raw?: string;
+    fm?: Record<string, any>;
+}, ctx: {
+    faces?: ReadonlyMap<string, import("./script-fonts.mjs").Face>;
+    maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>;
+}): object[];
+/**
+ * One row per native form of a language note's word, for the `natives`
+ * relation: a text is a value of a row, never a struct key, so forms that
+ * differ only in case stay apart.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {Array<Record<string, string|number|null>>} The rows; `word` is the
+ *   word's 0-based place in `data.words`, `native` the form's in its `native`.
+ */
+export function nativeRows(records: Iterable<Record<string, any>>): Array<Record<string, string | number | null>>;
+/** Every column of the `natives` relation, in order. */
+export const NATIVE_COLUMNS: readonly string[];
+/**
+ * One native form, read.
+ */
+export type NativeForm = {
+    /**
+     * - The map it is written for.
+     */
+    map: string;
+    /**
+     * - The one face it is for.
+     */
+    font: string | undefined;
+    /**
+     * - The word in the script.
+     */
+    text: string;
+};
+/**
+ * One word of a lexicon.
+ */
+export type LexiconWord = {
+    /**
+     * - The word as cited.
+     */
+    form: string;
+    /**
+     * - Its class.
+     */
+    class: string | null;
+    /**
+     * - Its senses, joined by `; `.
+     */
+    gloss: string | null;
+    /**
+     * - Its native forms.
+     */
+    natives: readonly NativeForm[];
+};
+/**
+ * A language's lexicon.
+ */
+export type Lexicon = {
+    /**
+     * - The language's configured name.
+     */
+    language: string;
+    /**
+     * - Its words, in `data.words` order.
+     */
+    words: readonly LexiconWord[];
+    /**
+     * - The native
+     * forms by the word's form, NFC; the first word of a form keeps it.
+     */
+    byForm: ReadonlyMap<string, readonly NativeForm[]>;
+};
+/**
+ * What a run, a passage or a listing is mapped by.
+ */
+export type Mapping = {
+    /**
+     * - The map.
+     */
+    map: import("./text-maps.mjs").TextMap;
+    /**
+     * - The face, whose own rows come first.
+     */
+    font: string | undefined;
+    /**
+     * - The
+     * language's native forms under the map in the face.
+     */
+    native: ((word: string) => string | undefined) | undefined;
+};

package/types/engine/markup-validation.d.mts

@@ -4,9 +4,14 @@
  * @param {string} source - Complete Markdown source, optionally with frontmatter.
  * @param {string} file - Diagnostic filename.
  * @param {import("./content-session.mjs").ContentSyntax} [syntax] - Exact-text scanner projections.
- * @returns {Array<{file: string, line: number, column: number, severity: string, message: string}>} Syntax errors.
+ * @param {import("./content-scripts.mjs").RunContext} [runs] - The package's
+ *   languages, faces and maps. Given, text marked with `lang=`, `font=` and
+ *   `map=` is checked against them; a caller with no package configuration
+ *   leaves it out.
+ * @returns {Array<{file: string, line: number, column: number, severity: string, message: string}>} Syntax errors,
+ *   then warnings.
  */
-export function markupFindings(source: string, file: string, syntax?: import("./content-session.mjs").ContentSyntax): Array<{
+export function markupFindings(source: string, file: string, syntax?: import("./content-session.mjs").ContentSyntax, runs?: import("./content-scripts.mjs").RunContext): Array<{
     file: string;
     line: number;
     column: number;

package/types/engine/note-vocabulary.d.mts

@@ -423,7 +423,7 @@ export type DataFieldSpec = {
      * - The anchor kinds an
      * Address here may name with `#<anchor>`. Absent, an anchor is refused.
      */
-    anchors?: readonly ("event" | "prose")[] | undefined;
+    anchors?: readonly ("prose" | "event")[] | undefined;
     /**
      * - The Address names exactly one event: an
      * anchor of kind `event`, or a note holding one event and no more.