@heroiclands/package-build 25.0.0 → 25.1.1

package/engine/extension-attributes.mjs

@@ -146,6 +146,8 @@ export function refusedAttributes(values) {
             problems.push(
                 `set ${key} with ${key.toLowerCase() === "id" ? "#id" : ".class"} rather than ${key}=`,
             );
+        } else if (key === "map") {
+            problems.push("map is not an attribute");
         } else if (/^on/i.test(key)) {
             problems.push(`${key} is an event handler and is not written`);
         }

package/engine/helpers.mjs

@@ -194,7 +194,7 @@ function localAssetImageInfo() {
  *   {@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
+ *   `enc=` is rewritten first, so it is tagged for its language, mapped and
  *   set in its font.
  * @returns {string} The rendered HTML.
  */

package/engine/index.mjs

@@ -331,3 +331,10 @@ export {
 
 /** The curated region-event vocabulary, shared with the Foundry runtime. */
 export * as regionEvents from "./region-events.mjs";
+
+/** Browser-safe encoding-document compilation and conversion. */
+export * as encoding from "./encoding.mjs";
+export * as encodingLanguage from "./encoding-language.mjs";
+/** Consumer-root file loading and authored language projections. */
+export * as encodingNotes from "./encoding-notes.mjs";
+export * as encodingLexicon from "./encoding-lexicon.mjs";

package/engine/language-terms.mjs

@@ -1696,7 +1696,7 @@ export const VERB_PERSON_FIELDS = Object.freeze(
 );
 
 /**
- * The endings `data.grammar.native` writes under a logographic map: the noun
+ * The endings `data.grammar.native` writes under a encoding: the noun
  * plural, then the six persons of the verb pattern.
  */
 export const WRITTEN_ENDINGS = Object.freeze([
@@ -1717,18 +1717,18 @@ const GRAMMAR_NATIVE_FIELDS = Object.freeze([
             "for a verb's present form.",
     }),
     Object.freeze({
-        name: "map",
+        name: "enc",
         kind: "string",
         required: true,
-        shape: "a logographic mapping note's `data.map.name`",
-        describe: "The logographic map the ending is written for.",
+        shape: "an encoding document Address",
+        describe: "The encoding the ending is written for.",
     }),
     Object.freeze({
         name: "font",
         kind: "string",
-        shape: "a face the map lists",
+        shape: "a face the encoding lists",
         describe:
-            "The one face the writing is for; unstated, it is for every face the map lists, " +
+            "The one face the writing is for; unstated, it is for every face the encoding lists, " +
             "and a writing stated for a face wins over it there.",
     }),
     Object.freeze({
@@ -1870,15 +1870,15 @@ const GRAMMAR_FIELDS = Object.freeze([
     Object.freeze({
         name: "native",
         kind: "list",
-        shape: "a list of `{ ending, map, font?, text }`",
+        shape: "a list of `{ ending, enc, font?, text }`",
         entries: Object.freeze({
             kind: "map",
-            shape: "a map — `{ ending, map, font?, text }`",
+            shape: "a map — `{ ending, enc, font?, text }`",
             fields: GRAMMAR_NATIVE_FIELDS,
         }),
         describe:
-            "Under a logographic map, the signs a noun's plural or a verb's present form is " +
-            "written with after its stem's writing, one entry per ending, map and face.",
+            "Under an encoding, the signs a noun's plural or a verb's present form is " +
+            "written with after its stem's writing, one entry per ending, encoding and face.",
     }),
 ]);
 
@@ -1893,11 +1893,12 @@ export const LANGUAGE_DATA_FIELDS = Object.freeze([
     Object.freeze({
         name: "roman",
         kind: "string",
-        shape: "a literal NFC string of permitted characters, including case, accents, digits and punctuation",
+        shape: "a literal NFC string of additional source characters, including exact letter case and digits",
         describe:
-            "The exact Roman source characters this language permits, each once. No ranges, case " +
-            "expansion or inherited inventory; spaces and line breaks are structural. An empty " +
-            "string declares no written characters. Required on each configured language note.",
+            "The additional Roman source characters the language permits, each once. Standard " +
+            "punctuation and structural whitespace remain available. No ranges, case expansion " +
+            "or inherited inventory. An empty string declares no additions. Required on each " +
+            "configured language note.",
     }),
     Object.freeze({
         name: "grammar",
@@ -1906,8 +1907,8 @@ export const LANGUAGE_DATA_FIELDS = Object.freeze([
         fields: GRAMMAR_FIELDS,
         describe:
             "Optional noun plurals, one verb pattern, agreement, participles and the endings' " +
-            "logographic writings, for dictionary presentation, the mapped-run word check and " +
-            "logographic maps. Only the shape of supplied keys is " +
+            "native writings, for dictionary presentation, language word checks and encodings. " +
+            "Only the shape of supplied keys is " +
             "checked; no word must follow or state a rule. A language skill note only.",
     }),
     listOfMaps(

package/engine/{logographic.mjs → language-writings.mjs}

@@ -12,39 +12,19 @@
  */
 
 /**
- * **A logographic map writes meanings, so a word's writing comes from the
- * lexicon and never from its sound.** A mapping note stating
- * `data.map.logographic: true` writes each word of a run in this order:
- *
- * 1. **The word's own `native` entry** for the map, and for the run's face
- *    where an entry names one.
- * 2. **Otherwise its parts.** A word stating `built` is written by the
- *    writings of its pieces joined in order: a piece is a word of the
- *    lexicon, matched exactly and then with its joining hyphens taken off, or
- *    an affix of `data.affixes` with its own `native`; a word piece resolves
- *    by this same rule. A noun's plural and a verb's present forms are written
- *    by the stem's writing followed by the ending's, which
- *    `data.grammar.native` states by the ending's name: `plural`, or one of
- *    the six persons. A hyphenated word no entry states is written by its
- *    parts, each by this rule.
- * 3. **Otherwise the word has no writing**, which a run reports at the word.
- *
- * A run's word is matched case folded, so one roman form may stand for more
- * than one entry. Where those entries are written alike the word takes that
- * writing; where they differ, or one has a writing and another none, the word
- * is ambiguous, and the finding names every entry's gloss. A part matched to
- * entries written differently makes the word ambiguous the same way.
- *
- * @module
+ * Native word spellings under any encoding: authored entries first, then all
+ * stated parts, affixes and grammatical endings. Ambiguous spellings remain
+ * findings, with every matching gloss. Exact lexical forms precede folded
+ * lookup, preserving explicitly distinct capitalized spellings.
  */
 
-import { pluralOf } from "./dictionary-rows.mjs";
+import { pluralOf } from "./word-inflections.mjs";
 import { verbForm, verbPattern } from "./verb-pattern.mjs";
 import { parseWordClass } from "./word-classes.mjs";
 import { foldWord } from "./word-forms.mjs";
 import { glossText } from "./word-terms.mjs";
 
-/** Whether a value is a plain map. */
+/** Whether a value is a plain object. */
 const isMap = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
 
 /** A list value, or an empty one. */
@@ -65,17 +45,18 @@ const JOINS = /[–-]/u;
  */
 
 /**
- * The text a list of native entries states for a map in a face: the entry for
+ * The text a list of native entries states for a enc in a face: the entry for
  * the face, else the entry for no face.
  *
  * @param {unknown} natives - A `native` list as authored.
- * @param {string} map - The map's name.
+ * @param {string} enc - The encoding's name.
  * @param {string|undefined} font - The face.
  * @returns {string|undefined} The text.
  */
-export function nativeText(natives, map, font) {
+
+export function nativeText(natives, enc, font) {
     const entries = listOf(natives).filter(
-        (entry) => isMap(entry) && entry.map === map && typeof entry.text === "string",
+        (entry) => isMap(entry) && entry.enc === enc && typeof entry.text === "string",
     );
     const own = font === undefined ? undefined : entries.find((entry) => entry.font === font);
     return (own ?? entries.find((entry) => typeof entry.font !== "string"))?.text;
@@ -100,15 +81,15 @@ function oneOf(form, candidates) {
 }
 
 /**
- * The writings of a language's words under one logographic map in one face.
+ * The writings of a language's words under one encoding in one face.
  *
  * @param {Record<string, any>|undefined} data - The language note's `data`.
- * @param {string} map - The map's name.
+ * @param {string} enc - The encoding's name.
  * @param {string|undefined} font - The face.
  * @returns {{word: (word: string) => Writing, entry: (index: number) => Writing}}
  *   The writing of a run's word, and of the `data.words` entry at an index.
  */
-export function writingsOf(data, map, font) {
+export function writingsOf(data, enc, font) {
     const words = listOf(data?.words);
     const affixes = listOf(data?.affixes).filter(isMap);
     const grammar = isMap(data?.grammar) ? data.grammar : undefined;
@@ -127,7 +108,7 @@ export function writingsOf(data, map, font) {
      */
     const entry = (index, visiting) => {
         const word = words[index];
-        const own = nativeText(word?.native, map, font);
+        const own = nativeText(word?.native, enc, font);
         if (own !== undefined) return { text: own, source: "own" };
         const pieces = listOf(word?.built).filter((piece) => typeof piece === "string");
         if (!pieces.length || visiting.has(index)) return { missing: true };
@@ -148,7 +129,7 @@ export function writingsOf(data, map, font) {
             gloss: glossOf(word),
         })),
         ...matchedAffixes.map((affix) => {
-            const text = nativeText(affix.native, map, font);
+            const text = nativeText(affix.native, enc, font);
             return {
                 writing: /** @type {Writing} */ (
                     text === undefined ? { missing: true } : { text, source: "own" }
@@ -192,7 +173,7 @@ export function writingsOf(data, map, font) {
     const endingText = (ending) =>
         nativeText(
             listOf(endings).filter((one) => isMap(one) && one.ending === ending),
-            map,
+            enc,
             font,
         );
 
@@ -205,8 +186,18 @@ export function writingsOf(data, map, font) {
     const word = (written) => {
         const folded = foldWord(written);
         const none = new Set();
-        const stated = indexed.filter(({ word: one }) => foldWord(one.form) === folded);
-        if (stated.length) return oneOf(written, candidatesOf(stated, [], none));
+        const stages = [
+            indexed.filter(({ word: one }) => one.form === written),
+            indexed.filter(({ word: one }) => listOf(one.variants).includes(written)),
+            indexed.filter(({ word: one }) => foldWord(one.form) === folded),
+            indexed.filter(({ word: one }) =>
+                listOf(one.variants).some(
+                    (form) => typeof form === "string" && foldWord(form) === folded,
+                ),
+            ),
+        ];
+        for (const stated of stages)
+            if (stated.length) return oneOf(written, candidatesOf(stated, [], none));
         const stripped = indexed.filter(({ word: one }) => bare(foldWord(one.form)) === folded);
         if (stripped.length) return oneOf(written, candidatesOf(stripped, [], none));
         const derived = [];

package/engine/markup-validation.mjs

@@ -43,7 +43,7 @@ function shortcodeErrors(body) {
  * @param {import("./content-session.mjs").ContentSyntax} [syntax] - Exact-text scanner projections.
  * @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
+ *   `enc=` 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.

package/engine/note-vocabulary.mjs

@@ -140,6 +140,7 @@ import {
 } from "./language-words.mjs";
 import { checkGlossary } from "./glossary-entries.mjs";
 import { GUIDE_SOUND_FIELDS, LANGUAGE_DATA_FIELDS } from "./language-terms.mjs";
+import { ENCODING_NOTE_FIELDS } from "./encoding-terms.mjs";
 import { checkGuideSounds, checkLanguageData } from "./language-data.mjs";
 import { checkAffiliationReach } from "./culture-reach.mjs";
 import { checkLanguageNames, requiredGivenGenders } from "./language-names.mjs";
@@ -159,11 +160,9 @@ import { checkCitedPopulations, checkPopulation } from "./populations.mjs";
 import { MARKET_CLASSES, checkMarket } from "./market-class.mjs";
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
 import { checkSettlementTables } from "./settlement-tables.mjs";
-import { checkMapField } from "./text-maps.mjs";
 import { checkConceptList, checkCoreFlag } from "./core-vocabulary.mjs";
 import { METRE_KINDS, checkMetresField } from "./metre-declaration.mjs";
 import { checkLanguageEmphasis, checkScriptField } from "./script-emphasis.mjs";
-import { WRITTEN_IN_KEY, checkWrittenIn } from "./written-in.mjs";
 import {
     EMPHASIS_CONVENTIONS,
     LANGUAGE_EMPHASES,
@@ -1591,47 +1590,6 @@ export const BEING_ARCHETYPES = Object.freeze({
     guildsperson: "Has professional training, standing, or connections that open doors.",
 });
 
-/**
- * One row of a mapping note's `data.map.rows` or of a face's own `rows`.
- *
- * @type {object}
- */
-const MAP_ROW_ENTRY = Object.freeze({
-    kind: "list-or-map",
-    shape: "`[from, to]` or `{ from, to, before?, at? }`",
-    entries: Object.freeze({ ...TEXT, shape: "a string" }),
-    fields: Object.freeze([
-        {
-            name: "from",
-            ...TEXT,
-            shape: "a string of one or more characters",
-            required: true,
-            describe: "The one or more characters the row matches.",
-        },
-        {
-            name: "to",
-            ...TEXT,
-            shape: "a string, which may be empty",
-            required: true,
-            allowEmpty: true,
-            describe: "What the row writes in their place; empty to drop them.",
-        },
-        {
-            name: "before",
-            ...TEXT,
-            allowed: Object.freeze(["vowel", "consonant"]),
-            describe:
-                "`vowel` or `consonant`: what must follow the match for the " + "row to apply.",
-        },
-        {
-            name: "at",
-            ...TEXT,
-            allowed: Object.freeze(["start", "end"]),
-            describe: "`start` or `end`: where the match must sit for the row to " + "apply.",
-        },
-    ]),
-});
-
 /**
  * Every note type this toolchain compiles, and the closed vocabulary it
  * declares.
@@ -2187,36 +2145,10 @@ export const NOTE_VOCABULARY = Object.freeze({
                     "and `words` marks it with a word, so either is a finding. Only a skill of " +
                     "`subType: language` states it.",
             },
-            {
-                name: WRITTEN_IN_KEY,
-                kind: "map",
-                shape: "a map — `{ map, font }`",
-                check: checkWrittenIn,
-                fields: Object.freeze([
-                    {
-                        name: "map",
-                        kind: "string",
-                        shape: "a mapping note's `data.map.name`",
-                        required: true,
-                        describe: "The map the language's text is written by.",
-                    },
-                    {
-                        name: "font",
-                        kind: "string",
-                        shape: "an installed face's slug",
-                        required: true,
-                        describe: "The face the text is set in, one the map is drawn in.",
-                    },
-                ]),
-                describe:
-                    "The script the language is written in, as the default map and face selected " +
-                    "by a run with explicit `lang=` and `.nativefont`; a run's own `map=` or " +
-                    "`font=` overrides its half. Only a skill of `subType: language` states it.",
-            },
             {
                 name: "script",
                 kind: "map",
-                shape: "a map — `{ fonts, emphasis, strongEmphasis?, direction? }`",
+                shape: "a map — `{ fonts, emphasis, direction? }`",
                 check: checkScriptField,
                 fields: Object.freeze([
                     {
@@ -2240,17 +2172,10 @@ export const NOTE_VOCABULARY = Object.freeze({
                         required: true,
                         describe:
                             "How the script marks a stressed word: `rubric` sets it in red, " +
-                            "`overline` draws a line above it. It sets `*…*` and `**…**` inside a " +
+                            "`overline` draws a line above it. It sets `.emph` and accepted English emphasis inside a " +
                             "run in one of its faces, unless the run's language states its own " +
                             "`emphasis`.",
                     },
-                    {
-                        name: "strongEmphasis",
-                        kind: "string",
-                        shape: "`rubric` or `overline`",
-                        allowed: EMPHASIS_CONVENTIONS,
-                        describe: "The convention `**…**` takes instead of `emphasis`'s.",
-                    },
                     {
                         name: "direction",
                         kind: "string",
@@ -2355,6 +2280,7 @@ export const NOTE_VOCABULARY = Object.freeze({
             ...checkPostFields(note),
         ],
         data: Object.freeze([
+            ...ENCODING_NOTE_FIELDS,
             CONCEPTS_FIELD,
             POST_DATE_FIELD,
             POST_AUTHOR_FIELD,
@@ -2375,86 +2301,6 @@ export const NOTE_VOCABULARY = Object.freeze({
                     "tongue of the setting: each letter row's `tongue` names the language notes " +
                     "that write it.",
             },
-            {
-                name: "map",
-                kind: "map",
-                shape: "a map — `{ name, logographic?, vowels?, fonts, rows }`",
-                check: checkMapField,
-                fields: Object.freeze([
-                    {
-                        name: "name",
-                        ...TEXT,
-                        required: true,
-                        describe:
-                            "What `map=` names the map by: lowercase letters, digits and `-`, " +
-                            "unique in the package.",
-                    },
-                    {
-                        name: "logographic",
-                        kind: "boolean",
-                        shape: "`true`",
-                        describe:
-                            "The script writes meanings: a mapped run's words are written by " +
-                            "the language's lexicon alone, and the rows write only the text " +
-                            "between them.",
-                    },
-                    {
-                        name: "vowels",
-                        ...TEXT,
-                        describe:
-                            "The characters a row's `before: vowel` reads as vowels; any other " +
-                            "letter is a consonant.",
-                    },
-                    {
-                        name: "rows",
-                        kind: "list",
-                        shape: "list of `[from, to]` or `{ from, to, before?, at? }`",
-                        required: true,
-                        entries: MAP_ROW_ENTRY,
-                        describe:
-                            "The rewrites, each `[from, to]` or `{ from, to, before?, at? }`: " +
-                            "`before` is `vowel` or `consonant`, `at` is `start` or `end`. The " +
-                            "longest `from` wins, and a character no row matches passes through.",
-                    },
-                    {
-                        name: "fonts",
-                        kind: "list",
-                        shape: "list of `{ font, rows? }`",
-                        required: true,
-                        entries: Object.freeze({
-                            kind: "map",
-                            shape: "a map — `{ font, rows? }`",
-                            fields: Object.freeze([
-                                {
-                                    name: "font",
-                                    ...TEXT,
-                                    required: true,
-                                    shape: "an installed face's slug",
-                                    describe:
-                                        "A face the map is drawn in, by the slug `font=` names it by.",
-                                },
-                                {
-                                    name: "rows",
-                                    kind: "list",
-                                    shape: "list of `[from, to]` or `{ from, to, before?, at? }`",
-                                    entries: MAP_ROW_ENTRY,
-                                    describe:
-                                        "Rows for this face alone, tried before the shared `rows`; " +
-                                        "the same shapes and conditions.",
-                                },
-                            ]),
-                        }),
-                        describe:
-                            "The faces the map is drawn in, at least one, each with any rows of " +
-                            "its own. A run in another face is refused, and each face must draw " +
-                            "every character its rows and the lexicon's native forms write.",
-                    },
-                ]),
-                describe:
-                    "A mapping, which native text marked with `lang=`, `.nativefont` and its " +
-                    "`map=` name is rewritten by before it is set. See " +
-                    "[mapping notes](format-details.md#mapping-notes).",
-            },
             {
                 name: "metres",
                 kind: "list",

package/engine/pdf-render.mjs

@@ -318,12 +318,24 @@ function reportUnrenderable(source, definitions, opts, original) {
     if (!findings) return;
     const file = opts.file ? { file: opts.file } : {};
     /**
-     * @param {{line: number, column?: number}} position - Where it is.
+     * @param {{file?: string, line: number, column?: number}} position - Where it is.
      * @param {"warning"|"error"} severity - Which level.
      * @param {string} message - What is wrong.
      * @returns {void}
      */
     const report = (position, severity, message) => {
+        if (
+            position.file &&
+            position.file !== opts.file &&
+            findings.some(
+                (one) =>
+                    one.file === position.file &&
+                    one.line === position.line &&
+                    one.column === position.column &&
+                    one.message === message,
+            )
+        )
+            return;
         findings.push({ ...file, ...position, severity, message });
     };
 
@@ -357,7 +369,13 @@ function reportUnrenderable(source, definitions, opts, original) {
         ...scanRuns(source, opts.runs).errors,
         ...markupAnchorFindings(source),
     ])
-        report(linePosition(error.line, error.column, opts), "error", error.message);
+        report(
+            error.file ?
+                { file: error.file, line: error.line, column: error.column }
+            :   linePosition(error.line, error.column, opts),
+            "error",
+            error.message,
+        );
     for (const error of scanFigures(source).errors)
         report(linePosition(error.line, error.column, opts), "error", error.message);
     // An image sharing its paragraph with other text, or an address or title
@@ -450,7 +468,7 @@ function reportUnrenderable(source, definitions, opts, original) {
  *   finding.
  * @param {import("./content-scripts.mjs").RunContext} [opts.runs] - The
  *   package's languages, faces and maps, which text marked with `lang=`,
- *   `font=` and `map=` is checked against and set by.
+ *   `font=` and `enc=` is checked against and set by.
  * @param {number} [opts.bodyLine] - The 1-based file line the body starts on, so
  *   a finding's line is the file's rather than the body's.
  * @param {number} [opts.bodyColumn] - The 1-based column the body starts at.
@@ -1413,6 +1431,16 @@ function renderInline(token, ctx) {
                 out.push(inlineRaw(child.content));
                 break;
             case "span_open": {
+                if (["em", "strong"].includes(child.tag)) {
+                    const classes = (child.attrGet?.("class") ?? "").split(/\s+/);
+                    out.push(
+                        classes.includes("emph-rubric") ?
+                            `#text(fill: ${ctx.textFill ?? "book-rubric"})[`
+                        : classes.includes("emph-overline") ? "#overline["
+                        : `#${child.tag === "em" ? "emph" : "strong"}[`,
+                    );
+                    break;
+                }
                 const sign = renderGlyph(children, i, ctx) ?? renderCartouche(children, i, ctx);
                 if (sign) {
                     out.push(sign.typst);