@heroiclands/package-build 24.0.3 → 24.0.4

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # @heroiclands/package-build
 
+## 24.0.4
+
+### Patch Changes
+
+**Languages**
+
+- Core vocabulary coverage uses only the nearest definition when a language
+  redefines an inherited expression.
+
+- Inherited dictionary words appear in a daughter language’s script with the
+  applicable native spelling.
+
+**Verse**
+
+- Parallel verse keeps its Roman reading beside the native script, with
+  gaps between stanzas.
+
 ## 24.0.3
 
 ### Patch Changes

package/docs/authoring/links-and-markup.md

@@ -490,7 +490,11 @@ column stacks one or more **entries**, joined by `:`. An entry is
 - **`mapping`** names a [mapping note](#mapping-notes), which rewrites the
   line before it is set. Left out, the line is set as written.
 - **`font`** names a face or a generic family, as `font=` does. Left out, the
-  line is set in the roman serif.
+  line keeps the page's normal typeface.
+
+A language-only entry stays in Roman letters even when the language's
+`data.writtenIn` names its usual script. Ordinary language-marked prose still
+selects that script automatically; columns use the entry's explicit mapping.
 
 A poem has at most two columns, and either may be left out. In every column
 the first entry is set in the normal tone and each later one in grey.
@@ -805,7 +809,12 @@ is one of them.
 
 **With `lang=`, the language's dictionary comes first.** Where
 [`languages.<name>.note`](../configuration.md#languages) names the language's
-note, each word of the run is looked up in its `data.words`:
+note, each word of the run is looked up in its `data.words` and the words of
+its `data.family` chain. The nearest exact NFC form supplies the entire word
+entry, including variants and native spellings; an override replaces the whole
+ancestor entry. Case and word separators remain part of that identity.
+Grammar, registered names and the default writing script remain the daughter's
+own. An inherited native spelling applies only to the map and face it names:
 
 1. **A word whose entry states a `native` form for the map** is written by it:
    the form stated for the run's face where there is one, else the form stated

package/docs/reference/format-details.md

@@ -6637,9 +6637,18 @@ The lint holds each to what it means, each finding located at the key at fault:
   Where no note states `data.concepts`, every id is unknown, and the message
   says so.
 
-A language reads the words of its `data.family` chain as its own, so a parent's
-tagged word covers the daughter's concept. `data.core` is not inherited: each
-language that must cover the list states it.
+A language reads the words of its `data.family` chain as its own. The nearest
+definition of a form wins, using the dictionary's matching: Unicode NFC, with
+case and word separators kept. If the daughter defines the same form, only
+that definition's `concept` ids count; an untagged definition covers none of
+the ancestor's concepts. A different inherited expression can still cover
+them. `data.core` is not inherited: each language that must cover the list
+states it.
+
+A `form` may contain several words. Its `gloss` records the expression's
+meaning, `built` may name its existing pieces, and `concept` may name every
+concept those senses support. The report counts declared ids; it does not
+prove an expression's meaning or infer coverage from grammar or untagged prose.
 
 `package-build core` is the report. A concept no word serves is never a lint
 finding; the report lists it so the language can be filled in. See

package/engine/content-scripts.mjs

@@ -91,6 +91,9 @@ import {
     expandVerseOrigins,
     scanVerse,
     sourcePosition,
+    hasColumns,
+    verseColumns,
+    STANZA_BREAK,
 } from "./content-verse.mjs";
 import { scanSpans } from "./content-spans.mjs";
 import { scanScrolls, scrollParagraphs } from "./content-scroll.mjs";
@@ -908,8 +911,23 @@ function analyseRuns(source, ctx, syntax) {
     collect(0, text);
 
     const poems = new Map();
+    const romanColumnLines = new Set();
     for (const poem of scanVerse(text).blocks) {
         poems.set(poem.start, poem);
+        // Expansion writes one span per display entry. An entry with no map
+        // keeps the source spelling and page font, even when its language
+        // normally selects a script. The fence itself holds only structure.
+        if (poem.classes.includes(COLUMNS_CLASS)) {
+            const entries = verseColumns(poem, lines[poem.start]).flatMap(
+                (column) => column.entries,
+            );
+            let entry = 0;
+            for (let line = poem.start + 1; line < poem.end; line++) {
+                if (!lines[line].trim() || STANZA_BREAK.test(lines[line].trim())) continue;
+                if (entries[entry++ % entries.length]?.map === undefined)
+                    romanColumnLines.add(line);
+            }
+        }
         const keys = runKeys(poem.attributes);
         if (!Object.keys(keys).length) continue;
         const opening = lines[poem.start];
@@ -1272,7 +1290,10 @@ function analyseRuns(source, ctx, syntax) {
         const keys = Object.assign({}, ...around(construct).map((c) => c.keys), construct.keys);
         // The language's script fills what the run leaves unstated, once its
         // own keys are known to name something.
-        if (named) Object.assign(keys, fromWrittenIn(keys, ctx.writtenIn, maps));
+        const columnSource = construct.kind === "span" && romanColumnLines.has(construct.line0);
+        const columnFence = construct.kind === "verse" && hasColumns(construct.node);
+        if (named && !columnSource && !columnFence)
+            Object.assign(keys, fromWrittenIn(keys, ctx.writtenIn, maps));
         if (construct.kind === "scroll" && named) {
             scrollFace(construct, keys);
             named = errors.length === unchecked;

package/engine/core-report.mjs

@@ -18,7 +18,8 @@
  * The list is the `data.concepts` of the package's `doc` notes. A language
  * must cover it where it states `data.core: true`. A word covers every
  * concept its `concept` names, and a language reads the words of its
- * `data.family` chain as its own. A missing concept is a fact to work through,
+ * `data.family` chain as its own, with the nearest definition of each form
+ * winning. A missing concept is a fact to work through,
  * never a finding.
  *
  * @module
@@ -114,9 +115,16 @@ export function coreReport(records, { language } = {}) {
         concepts: concepts.length,
         languages: chosen.map((record) => {
             const have = new Set();
+            const forms = new Set();
             for (const key of chain(noteAddressOf(record) ?? ""))
-                for (const word of byKey.get(key)?.data?.words ?? [])
+                for (const word of byKey.get(key)?.data?.words ?? []) {
+                    if (!isMap(word) || typeof word.form !== "string") continue;
+                    // Match dictionary headwords: NFC, retaining case and word separators.
+                    const form = word.form.normalize("NFC");
+                    if (forms.has(form)) continue;
+                    forms.add(form);
                     for (const id of idsOf(word)) have.add(id);
+                }
             const missing = [];
             for (const group of groups) {
                 const members = concepts.filter((concept) => concept.group === group);

package/engine/map-lexicon.mjs

@@ -59,7 +59,7 @@ import { fromWrittenIn } from "./written-in.mjs";
 import { writingsOf } from "./logographic.mjs";
 import { FONTS_PACKAGE } from "./script-fonts.mjs";
 import { GENERIC_FAMILIES, applyMap } from "./text-maps.mjs";
-import { isLanguageRecord, noteAddressOf } from "./word-rows.mjs";
+import { isLanguageRecord, lineageChain, noteAddressOf } from "./word-rows.mjs";
 import { derivedForms } from "./word-forms.mjs";
 import { LANGUAGE_SUBTYPE, glossText } from "./word-terms.mjs";
 
@@ -183,7 +183,7 @@ function lexiconOf(language, data) {
  * @returns {string|undefined} The Address.
  */
 function noteKey(note, contentPackage, types) {
-    if (typeof note !== "string" || !contentPackage) return undefined;
+    if (!contentPackage) return undefined;
     const tuple = parseAddress(
         note,
         { package: contentPackage, system: "note", type: "skill", types: new Set(types) },
@@ -248,7 +248,9 @@ function languageNotes(languages, contentPackage, records) {
 
 /**
  * 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.
+ * names and its family chain. The nearest exact NFC form supplies the whole
+ * word; grammar, registers and other settings remain the daughter's own.
+ * 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 -
@@ -256,9 +258,39 @@ function languageNotes(languages, contentPackage, records) {
  * @returns {Map<string, Lexicon>} The lexicons by language name.
  */
 export function lexiconsFromRecords(records, config = {}) {
+    const list = [...(records ?? [])];
+    const byKey = recordsByKey(list, config.contentPackage);
+    const types = new Set(["skill", ...list.map((record) => record?.type).filter(Boolean)]);
+    const lineage = {
+        has: (key) => isLanguage(byKey.get(key)),
+        parentOf: (key) => {
+            const record = byKey.get(key);
+            return noteKey(record.data?.family, record.package ?? config.contentPackage, types);
+        },
+    };
     const lexicons = new Map();
-    for (const [name, record] of languageRecordsByName(records, config))
-        lexicons.set(name, lexiconOf(name, record.data));
+    for (const [name, { key, record }] of languageNotes(
+        config.languages,
+        config.contentPackage,
+        list,
+    )) {
+        if (!record) continue;
+        const chain = lineageChain(key, lineage);
+        let data = record.data;
+        if (chain.length > 1) {
+            const words = new Map();
+            for (const ancestor of chain)
+                for (const word of listOf(byKey.get(ancestor).data?.words)) {
+                    if (!isMap(word) || typeof word.form !== "string") continue;
+                    // The nearest complete definition wins before word matching
+                    // folds case or splits compounds. Only words are inherited.
+                    const form = word.form.normalize("NFC");
+                    if (!words.has(form)) words.set(form, word);
+                }
+            data = { ...data, words: [...words.values()] };
+        }
+        lexicons.set(name, lexiconOf(name, data));
+    }
     return lexicons;
 }
 

package/engine/run-words.mjs

@@ -36,7 +36,7 @@
  * @module
  */
 
-import { languageRecordsByName } from "./map-lexicon.mjs";
+import { lexiconsFromRecords } from "./map-lexicon.mjs";
 import { RESERVED_TONGUE } from "./language-terms.mjs";
 import { addWords, foldWord, lexiconWords } from "./word-forms.mjs";
 import { WORD } from "./word-pattern.mjs";
@@ -82,7 +82,8 @@ export function registeredNameWords(data) {
 
 /**
  * Each configured language's word book: one per language whose `note` names a
- * language note.
+ * language note. Its effective lexicon shares the renderer's nearest inherited
+ * words, and derives forms and registered names from its own settings.
  *
  * @param {Iterable<Record<string, any>>|undefined} records - Index records.
  * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
@@ -92,11 +93,10 @@ export function registeredNameWords(data) {
 export function wordBooksFromRecords(records, config = {}) {
     const list = [...(records ?? [])];
     const books = new Map();
-    const languages = languageRecordsByName(list, config);
-    if (!languages.size) return books;
-    for (const [name, record] of languages) {
-        const own = lexiconWords(record.data);
-        const names = registeredNameWords(record.data);
+    const lexicons = lexiconsFromRecords(list, config);
+    for (const [name, lexicon] of lexicons) {
+        const own = lexiconWords(lexicon.data);
+        const names = registeredNameWords(lexicon.data);
         books.set(
             name,
             Object.freeze({

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "24.0.3",
+    "version": "24.0.4",
     "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",

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

@@ -1,6 +1,8 @@
 /**
  * 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.
+ * names and its family chain. The nearest exact NFC form supplies the whole
+ * word; grammar, registers and other settings remain the daughter's own.
+ * 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 -

package/types/engine/run-words.d.mts

@@ -17,7 +17,8 @@ export function registeredNameWords(data: Record<string, any> | undefined): Set<
  */
 /**
  * Each configured language's word book: one per language whose `note` names a
- * language note.
+ * language note. Its effective lexicon shares the renderer's nearest inherited
+ * words, and derives forms and registered names from its own settings.
  *
  * @param {Iterable<Record<string, any>>|undefined} records - Index records.
  * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -