@heroiclands/package-build 24.1.1 → 25.0.0

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @heroiclands/package-build
 
+## 25.0.0
+
+### Major Changes
+
+**Languages and scripts**
+
+- Add `data.roman` to every configured language note: an NFC string listing each
+  permitted Roman character once, with capitals, accents, digits and punctuation
+  explicit.
+- Use `""` for no written characters; omit spaces and line breaks, and declare
+  inventories without ranges, automatic case expansion or inheritance. Maps and
+  fonts grant no extra Roman characters.
+- Language-tagged source and visible link labels are checked before mapping;
+  configured names and their BCP 47 tags select the same inventory.
+- Invalid characters and non-NFC spellings are reported at their original
+  positions; link destinations, attributes and verse structure are excluded.
+- Only period maps to Semaron's pause; recognized native signs require explicit
+  native presentation and a face that draws them, while mappings never broaden
+  Roman inventories.
+- Unassociated external tags such as `en` and `zxx` retain ordinary behavior;
+  standalone `package-build markdown` does not load language inventories.
+
 ## 24.1.1
 
 ### Patch Changes

package/docs/api.md

@@ -1384,17 +1384,29 @@ Linting a content tree's **addresses** — the rules every package's notes are a
 
 The charset authored content is held to, so a book can choose its face. The packs and the website render in whatever font the reader's browser or Foundry supplies, and a glyph nobody has is somebody else's problem. **A book is not that.** A PDF embeds the faces it sets, so every character in the corpus is a claim on the book's typeface — and the claim is silent, which is what makes it expensive.
 
-| Export               | Signature                                  | Returns                                                                                                                                                                  | Use it when                                                                |
-| -------------------- | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------- |
-| `isLetterTier`       | `function isLetterTier(cp)`                | {boolean} Whether Tier 1 admits it.                                                                                                                                      | Tier 1 — the letters, and the two whitespace characters a file is made of. |
-| `TYPOGRAPHY`         | `const TYPOGRAPHY`                         | —                                                                                                                                                                        | Tier 2 — typography, enumerated one codepoint at a time.                   |
-| `NOTATION`           | `const NOTATION`                           | —                                                                                                                                                                        | Tier 3 — the notation the rules and price tables are written in.           |
-| `isAllowedCodePoint` | `function isAllowedCodePoint(cp)`          | {boolean} Whether it is allowed outside a code fence.                                                                                                                    | Whether the charset admits a code point anywhere in a note.                |
-| `isDiagramCodePoint` | `function isDiagramCodePoint(cp)`          | {boolean} Whether a fence may carry it.                                                                                                                                  | Whether a code point is diagram furniture, admitted inside a fence only.   |
-| `refusalFor`         | `function refusalFor(cp)`                  | {string} A clause naming what it is and what to do instead.                                                                                                              | The reason a code point is refused.                                        |
-| `decomposedRuns`     | `function decomposedRuns(text)`            | {Array<{sequence: string, composed: string, index: number}>} Each offending run, in the order it appears.                                                                | Every non-NFC run in a string, with the composed form it should have been. |
-| `checkText`          | `function checkText(text, file)`           | {Array<{file: string, line: number, column: number, severity: "warning", message: string}>} What is wrong, in file order.                                                | Check one file's text against the charset and the normalization rule.      |
-| `lintContentCharset` | `function lintContentCharset(contentBase,` | `{{findings: Array<{file: string, line: number, column: number, severity: "warning", message: string}>, files: number}}` The findings, and how many files produced them. | Walk a content tree and check every authored file in it.                   |
+| Export                     | Signature                                  | Returns                                                                                                                                                                  | Use it when                                                                                  |
+| -------------------------- | ------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------- |
+| `isLetterTier`             | `function isLetterTier(cp)`                | {boolean} Whether Tier 1 admits it.                                                                                                                                      | Tier 1 — the letters, and the two whitespace characters a file is made of.                   |
+| `TYPOGRAPHY`               | `const TYPOGRAPHY`                         | —                                                                                                                                                                        | Tier 2 — typography, enumerated one codepoint at a time.                                     |
+| `NOTATION`                 | `const NOTATION`                           | —                                                                                                                                                                        | Tier 3 — the notation the rules and price tables are written in.                             |
+| `isSettingScriptCodePoint` | `isSettingScriptCodePoint(cp)`             | `boolean`                                                                                                                                                                | recognizing native setting-script input before the selected face checks the individual glyph |
+| `isAllowedCodePoint`       | `function isAllowedCodePoint(cp)`          | {boolean} Whether it is allowed outside a code fence.                                                                                                                    | Whether the charset admits a code point anywhere in a note.                                  |
+| `isDiagramCodePoint`       | `function isDiagramCodePoint(cp)`          | {boolean} Whether a fence may carry it.                                                                                                                                  | Whether a code point is diagram furniture, admitted inside a fence only.                     |
+| `refusalFor`               | `function refusalFor(cp)`                  | {string} A clause naming what it is and what to do instead.                                                                                                              | The reason a code point is refused.                                                          |
+| `decomposedRuns`           | `function decomposedRuns(text)`            | {Array<{sequence: string, composed: string, index: number}>} Each offending run, in the order it appears.                                                                | Every non-NFC run in a string, with the composed form it should have been.                   |
+| `checkText`                | `function checkText(text, file)`           | {Array<{file: string, line: number, column: number, severity: "warning", message: string}>} What is wrong, in file order.                                                | Check one file's text against the charset and the normalization rule.                        |
+| `lintContentCharset`       | `function lintContentCharset(contentBase,` | `{{findings: Array<{file: string, line: number, column: number, severity: "warning", message: string}>, files: number}}` The findings, and how many files produced them. | Walk a content tree and check every authored file in it.                                     |
+
+### `engine.romanCharacters`
+
+Exact permitted Roman source characters for configured languages, before script
+mapping. Inventories come from `data.roman` on each language's own note.
+
+| Export                   | Signature                                     | Returns                       | Use it when                                                                                   |
+| ------------------------ | --------------------------------------------- | ----------------------------- | --------------------------------------------------------------------------------------------- |
+| `romanInventoryProblems` | `romanInventoryProblems(value)`               | `string[]`                    | checking NFC, repeated characters and forbidden whitespace or controls in a literal inventory |
+| `romanInventoriesOf`     | `romanInventoriesOf(records, languages)`      | `Map<string, RomanInventory>` | looking up a configured language's own inventory by name or BCP 47 tag                        |
+| `romanTextProblems`      | `romanTextProblems(text, inventory, native?)` | `{offset, message}[]`         | validating visible unescaped source with exact offsets and an optional native-sign predicate  |
 
 ### `engine.pathCharset`
 

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

@@ -644,6 +644,14 @@ has an error is set exactly as written.
 
 ## Marking language, font and mapping
 
+Each configured language note declares `data.roman`, a literal NFC string of
+permitted source characters. Include capitals, accents, digits and punctuation
+explicitly; an empty string declares no written characters. Spaces and line
+breaks are structural. `package-build lint` checks Roman source before mapping,
+including language-only runs and visible link labels. The configured name and
+its BCP 47 tag select the same inventory; external tags without a configured
+language note keep their ordinary behavior.
+
 `lang=` identifies the language. It preserves the authored spelling and the
 surrounding prose font. Add **`.nativefont`** to request native script:
 

package/docs/commands.md

@@ -2215,6 +2215,14 @@ dependencies; exact Item UUID validation remains part of compilation. Reads
 the content tree named by `root`, defaulting to
 `paths.content`; writes nothing.
 
+Every configured language note declares `data.roman`, its exact NFC Roman
+source characters. Lint checks language-tagged text before mapping, using the
+same inventory for a configured name and its BCP 47 tag. Visible linked labels
+are checked; destinations, attributes and verse structure are excluded. An
+explicit empty inventory declares no written characters. External tags without
+a language-note association retain their ordinary behavior. Standalone
+`package-build markdown` does not load these inventories.
+
 Name marking is advisory: lint checks explicit `.name` spans and authored link
 labels against the [name-marking
 conventions](authoring/links-and-markup.md#marking-names-in-prose). Plain prose

package/docs/guides/writing-in-invented-scripts.md

@@ -158,6 +158,7 @@ language note says which, as one map and one face:
 
 ```yaml
 data:
+  roman: "ABDEFGHIKLMNOPRSTUVWYZabdefghiklmnoprstuvwyzÁÉÍÓÚÝáéíóúýËëÀà0123456789."
   writtenIn: { map: semaron, font: semaron-kuriale }
 ```
 
@@ -300,7 +301,6 @@ data:
       - { from: "y", to: "󰉅", before: vowel } # U+F0245
       - ["y", "󰈷"] # U+F0237
       - [".", "󰉨"] # U+F0268
-      - [",", "󰉨"] # U+F0268
     fonts: [{ font: semaron-kuriale }]
 ---
 
@@ -339,8 +339,8 @@ them, none included. A mapping that drops a language's vowels writes `[a, ""]`.
   `y` is the consonant letter before a vowel and the vowel `i` elsewhere.
 - **Capitals and marks need rows of their own.** A row matches the character as
   written, so `L` and `l` are two rows, and a script with no capitals gives both
-  the same code point. The full stop and the comma are characters too: a run
-  that holds one needs a row for it, or the face-coverage check reports it.
+  the same code point. A period is a character too and needs its own row.
+  A language's `data.roman` decides which source characters may appear.
 - **A character no row matches passes through unchanged,** and the face-coverage
   check then reports it. A mapping for a face that draws nothing on roman code
   points lists every letter the spelling uses.
@@ -381,14 +381,19 @@ A row with a fault is left out of the map and the rest apply.
 
 ## How a mapping treats punctuation
 
+The language note's `data.roman` lists its exact permitted Roman source
+characters. Include capitals, accents, digits and punctuation explicitly;
+`package-build lint` checks them before mapping. A map cannot admit a character
+that the language's inventory excludes. There are no automatic punctuation
+substitutions.
+
 The toolchain is used with one convention for marks: **mood, questions and
 quotation are carried by words, not marks,** unless a language's note rules
 otherwise. A mapping therefore lists the marks its script has and nothing more.
-In the sample, a comma and a full stop are the script's one point:
+In the sample, only a period writes the script's pause point:
 
 ```yaml
 - [".", "\U000F0268"] # U+F0268
-- [",", "\U000F0268"] # U+F0268
 ```
 
 (Formatting rewrites the escapes, as above.) A character with no row passes
@@ -398,10 +403,11 @@ mapped run is an error that names the mark and the mapping:
 > `` `?` (U+003F) is not drawn by the font `semaron-kuriale`, and the map `semaron` has no row for it ``
 
 The remedy is to write the question or the quotation in words, as the language
-does, and leave the mark out of the run. A language whose note rules
-otherwise gets rows for its marks in the mapping, and the check stops
-reporting them. The same holds for the digits, the hyphen and the catch: a row
-for each makes the mark part of the script; none leaves it out.
+does, and leave the mark out of the run. A language whose note permits a mark
+includes it in `data.roman`; its script needs a row for that mark as well.
+Vylari permits period alone as punctuation. Its lexical catch is written with
+a grave-accented vowel, as in `kàralzon`, and that vowel needs its own mapping
+row; an apostrophe is not another spelling of it.
 
 ## The dictionary first
 
@@ -793,7 +799,7 @@ paragraphs: indentation, line breaks and spans survive formatting untouched.
 
 ````markdown
 ```verse {lang=vyl font=semaron-kuriale map=semaron .nativefont}
-Lokazor lonak,
+Lokazor lonak.
   lokamen zaron.
 ```
 ````
@@ -1114,6 +1120,7 @@ name: { full: Vylari Language }
 type: skill
 subType: language
 data:
+  roman: "ABDEFGHIKLMNOPRSTUVWYZabdefghiklmnoprstuvwyzÁÉÍÓÚÝáéíóúýËëÀà0123456789."
   writtenIn: { map: semaron, font: semaron-kuriale }
   core: true
   fields:
@@ -1177,7 +1184,7 @@ The lintel over the door of the oath road is cut with a couplet, and the
 stonecutter set the couplet in the script of the court, so that every traveller
 could read it as the court reads it.
 
-[Lokazor lonak thiruthrimar, lokamen zaron.]{lang=vyl font=semaron-kuriale map=semaron .nativefont}
+[Lokazor lonak thiruthrimar. lokamen zaron.]{lang=vyl font=semaron-kuriale map=semaron .nativefont}
 ```
 
 Linting reports the unknown word, at its first character:
@@ -1198,6 +1205,7 @@ name: { full: Vylari Language }
 type: skill
 subType: language
 data:
+  roman: "ABDEFGHIKLMNOPRSTUVWYZabdefghiklmnoprstuvwyzÁÉÍÓÚÝáéíóúýËëÀà0123456789."
   writtenIn: { map: semaron, font: semaron-kuriale }
   core: true
   fields:
@@ -1251,7 +1259,7 @@ The lint is now clean, and the conversion can be read. `package-build transliter
 prints the code points the build writes for the couplet:
 
 ```console
-$ package-build transliterate semaron --lang vyl --hex "Lokazor lonak, lokamen zaron."
+$ package-build transliterate semaron --lang vyl --hex "Lokazor lonak. lokamen zaron."
 U+F020A U+F023D U+F0239 U+F0230 U+F0246 U+F023D U+F023F U+0020 U+F023A U+F023D U+F023C U+F0230 U+F0239 U+F0268 U+0020 U+F023A U+F023D U+F0239 U+F0230 U+F023B U+F0233 U+F023C U+0020 U+F0246 U+F0248 U+F023F U+F023D U+F023C U+F0268
 ```
 
@@ -1264,8 +1272,8 @@ The site sets the run as
 ```
 
 where the characters are the code points above: `Lokazor` begins with the
-capital `L` of the rows, `zaron` is the exception's long vowel, and the comma
-and full stop are the script's one point.
+capital `L` of the rows, `zaron` is the exception's long vowel, and each period
+writes the script's pause point.
 
 A poem in columns and a poem with its metre checked sit on one note. Both parse
 with no finding: the first sets native Vylari in column one and English over Roman
@@ -1341,7 +1349,7 @@ The door is marked with the same words as the lintel. Although Semaron's
 convention is rubric, this Vylari span uses no Markdown emphasis: spans with a
 non-English language cannot contain bold or italic markup.
 
-[Lokazor lonak, zaron.]{lang=vyl font=semaron-kuriale map=semaron .nativefont}
+[Lokazor lonak. zaron.]{lang=vyl font=semaron-kuriale map=semaron .nativefont}
 ```
 
 Finally, the core report lists what the language still lacks:

package/docs/reference/format-details.md

@@ -2002,6 +2002,30 @@ in that column are grey; each row resets that choice. `numstep` counts logical
 rows, and `***` separates stanzas. Language and native script choices remain
 on the authored inline runs, independently for every reading.
 
+**A language note declares its Roman source inventory in `data.roman`.** It is
+one literal NFC string containing each permitted character once, including every
+capital, accent, digit and punctuation mark the language uses. For example,
+`roman: "kaKàÀ.1"` permits exactly those seven characters. There is no range
+syntax, automatic case expansion, or inventory inherited from a parent language.
+An empty string explicitly declares that the language has no written characters.
+Spaces, tabs and line breaks are structural and are not listed in the inventory.
+A missing declaration on a configured language note is an error even when no
+passage uses the language. A directly typed native sign is separate from
+Roman input only when the run explicitly selects `.nativefont`, the character
+belongs to a recognized setting-script encoding, and the selected face draws it.
+A font's ability to draw Roman punctuation does not admit that punctuation.
+
+`package-build lint` checks the visible source of language-tagged spans, divs,
+verse and scroll fences against that inventory before any map or native-word
+replacement can hide a character. Both the configured name and its BCP 47 tag
+select the same inventory. A nested language selects its own; link destinations,
+attributes, column numbers, indentation periods and `***` stanza separators are
+structure. Escaping a character does not admit it. Source spelling must be NFC;
+errors retain the original file position. Unassociated external tags such as
+`en` and `zxx` keep their ordinary behavior. Standalone `package-build markdown`
+checks markup without loading language inventories. Structured frontmatter words
+are separate from prose runs.
+
 **A face draws the code points its `fonts.json` entry lists in `codepoints`,
 and whitespace.** After the map, any other character in a run set in a face is
 an error, located at the source character it came from; through a map, at the
@@ -6095,6 +6119,7 @@ SoHL sets `system.quantity` to `1` for each compendium item.
 | `family`                                   | `Address`                                                                                                                      | `language` only: the parent language, naming a skill note with `subType: language`; this language reads the parent's words as its own — see [a language's words](#a-languages-words)           |
 | `abbreviation`                             | `string`                                                                                                                       | `language` only: the tag a dictionary prints for it, as `Prov.`; its full name where unstated — see [dictionaries and glossaries](#dictionaries-and-glossaries)                                |
 | `core`                                     | `boolean`                                                                                                                      | `language` only: `true` where the language must cover the [core vocabulary](#the-core-vocabulary)                                                                                              |
+| `roman`                                    | literal NFC string, may be empty                                                                                               | Exact permitted Roman source characters, including both cases, accents, digits and punctuation; required on each configured language note. No family inheritance or range syntax.              |
 | `grammar`                                  | `{ plural?, verbs?, agreement?, participles? }`                                                                                | Optional noun plurals, one verb pattern, agreement and participles; supplied shapes only are checked                                                                                           |
 | `grammar.plural`                           | `{ ending, becomes }[]`                                                                                                        | Literal suffix replacements in authored order; the first match wins                                                                                                                            |
 | `grammar.plural[].ending`                  | `string`, required, may be empty                                                                                               | Bare suffix to replace; empty matches every noun                                                                                                                                               |

package/docs/reference/note-types.md

@@ -468,6 +468,7 @@ These fields are accepted by every note type. A field's value can still be irrel
 | `data.fields`           | list of `{ name, holds }`                                                                                                                    | The fields the language's words are grouped under. A language skill note only.                                                                                                                                                                                                                                                                                                                        |
 | `data.words`            | list of `{ form, class, field, gloss, … }`                                                                                                   | The words this language states, one map each, in authored order; its automatic dictionary sorts them alphabetically. A language skill note only. See [a language's words](format-details.md#a-languages-words).                                                                                                                                                                                       |
 | `data.affixes`          | list of `{ form, gloss, attaches?, examples? }`                                                                                              | The affixes a word's `built` pieces may name, each with its gloss. A language skill note only.                                                                                                                                                                                                                                                                                                        |
+| `data.roman`            | a literal NFC string of permitted characters, including case, accents, digits and punctuation                                                | 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.                                                                                                                                               |
 | `data.grammar`          | a map — `{ plural?, verbs?, agreement?, participles?, native? }`                                                                             | 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 checked; no word must follow or state a rule. A language skill note only.                                                                                                      |
 | `data.tongues`          | list of `{ tag, meaning, language? }`                                                                                                        | The tags a register row's `tongue` may name, each with what it means. A language skill note only.                                                                                                                                                                                                                                                                                                     |
 | `data.register`         | list of `{ name, tongue?, kind?, built?, gloss?, why? }`                                                                                     | Every name the setting gives in the language's reach, with its tongue and pieces; the notes carrying each name are derived. A language skill note only.                                                                                                                                                                                                                                               |

package/engine/content-charset.mjs

@@ -176,6 +176,17 @@ const SCRIPT_BLOCKS = Object.freeze([
     [0x13430, 0x1345f], // the Egyptian format controls Zethu uses
 ]);
 
+/**
+ * Whether a code point belongs to a declared setting-script encoding block.
+ * This identifies native input independently of a language's Roman inventory;
+ * a selected native face must still draw the individual character.
+ * @param {number} cp - A Unicode code point.
+ * @returns {boolean}
+ */
+export function isSettingScriptCodePoint(cp) {
+    return SCRIPT_BLOCKS.some(([from, to]) => cp >= from && cp <= to);
+}
+
 /**
  * Whether the charset admits a code point anywhere in a note.
  *
@@ -184,10 +195,7 @@ const SCRIPT_BLOCKS = Object.freeze([
  */
 export function isAllowedCodePoint(cp) {
     return (
-        isLetterTier(cp) ||
-        TYPOGRAPHY.has(cp) ||
-        NOTATION.has(cp) ||
-        SCRIPT_BLOCKS.some(([from, to]) => cp >= from && cp <= to)
+        isLetterTier(cp) || TYPOGRAPHY.has(cp) || NOTATION.has(cp) || isSettingScriptCodePoint(cp)
     );
 }
 

package/engine/content-format.yaml

@@ -200,6 +200,7 @@ types:
             - other
     skill:
         data:
+            - roman
             - grammar
             - templatePriority
             - masteryLevel

package/engine/content-scripts.mjs

@@ -92,7 +92,7 @@
 import MarkdownIt from "markdown-it";
 
 import { scanBlocks, BLOCK_CONTAINERS } from "./content-blocks.mjs";
-import { scanVerse, hasColumns, verseLine, verseGroups } from "./content-verse.mjs";
+import { scanVerse, hasColumns, verseLine, verseGroups, STANZA_BREAK } from "./content-verse.mjs";
 import { scanSpans } from "./content-spans.mjs";
 import { scanScrolls, scrollParagraphs } from "./content-scroll.mjs";
 import { directionsFromRecords } from "./script-direction.mjs";
@@ -113,7 +113,9 @@ import { unknownWordMessage, unknownWords, wordBooksFromRecords } from "./run-wo
 import { metreBooksFromRecords, metreFindings, metresFromRecords } from "./verse-metre.mjs";
 import { applyMap, mapsFromRecords } from "./text-maps.mjs";
 import { writtenInOf } from "./written-in.mjs";
-import { WIKILINK, parseWikilink } from "./wikilink-syntax.mjs";
+import { romanInventoriesOf, romanTextProblems } from "./roman-characters.mjs";
+import { isSettingScriptCodePoint } from "./content-charset.mjs";
+import { WIKILINK } from "./wikilink-syntax.mjs";
 import { matchAllOutsideCode } from "./code-fences.mjs";
 import { parseExtensionAttributes } from "./extension-attributes.mjs";
 
@@ -159,6 +161,8 @@ const CONFIG = "package-build.config.yaml";
  * @property {ReadonlyMap<string, import("./verse-metre.mjs").MetreBook>} [metreBooks] -
  *   What each configured language's verse is counted by, from
  *   {@link module:engine/verse-metre.metreBooksFromRecords}.
+ * @property {ReadonlyMap<string, import("./roman-characters.mjs").RomanInventory>} [romanInventories] -
+ *   Exact Roman source inventories by configured alias and BCP 47 tag.
  * @property {ReadonlyMap<string, import("./script-emphasis.mjs").Emphasis>} [emphases] -
  *   Each face's emphasis conventions, from the script notes, by
  *   {@link module:engine/script-emphasis.emphasesFromRecords}.
@@ -241,6 +245,7 @@ export function runContext(config, records) {
         ...base,
         maps,
         writtenIn: writtenInOf(languageRecords, maps),
+        romanInventories: romanInventoriesOf(languageRecords, config.languages),
         lexicons: lexiconsFromRecords(records, config),
         wordBooks: wordBooksFromRecords(records, config),
         metres: metresFromRecords(records),
@@ -1176,12 +1181,11 @@ function analyseRuns(source, ctx, syntax) {
             );
     };
 
+    const rawReferences = [];
     // Raw wikilinks belong to the resolver, not the span rewriter. Validate
     // their own control attributes with the same grammar before resolution,
     // without mapping a destination or consuming the trailing attributes.
     for (const match of matchAllOutsideCode(text, new RegExp(WIKILINK.source, "g"))) {
-        const parsed = parseWikilink(match[1], match[0]);
-        if (!parsed.attributes) continue;
         const close = match[0].indexOf("]]") + 1;
         const from = match.index + close + 2;
         const attrs = parseExtensionAttributes(match[0].slice(close + 2, -1), { positions: true });
@@ -1200,6 +1204,19 @@ function analyseRuns(source, ctx, syntax) {
         };
         const unchecked = errors.length;
         checkOwn(construct);
+        const bar = match[1].indexOf("|");
+        if (bar >= 0 && errors.length === unchecked) {
+            const ancestors = around(construct);
+            const inherited = ancestors.filter((parent) => parent.keys.lang !== undefined).at(-1)
+                ?.keys.lang;
+            rawReferences.push({
+                lang: construct.keys.lang ?? inherited,
+                from: match.index + 2 + bar + 1,
+                to: match.index + close - 1,
+                where: construct.where,
+                construct,
+            });
+        }
         if (errors.length !== unchecked || !native(construct)) continue;
         const keys = { ...construct.keys };
         nativeDefaults(construct, keys);
@@ -1215,6 +1232,9 @@ function analyseRuns(source, ctx, syntax) {
 
     const verseMarkers = new Map();
     for (const poem of scanVerse(text).blocks) {
+        for (let line = poem.start + 1; line < poem.end; line++)
+            if (STANZA_BREAK.test(lines[line].trim()))
+                verseMarkers.set(starts[line], starts[line] + lines[line].length);
         if (hasColumns(poem)) {
             for (const group of verseGroups(poem, lines)) {
                 if (group.stanzaBreak) continue;
@@ -1401,6 +1421,47 @@ function analyseRuns(source, ctx, syntax) {
         }
     };
 
+    /** The configured source inventory for either an alias or its BCP 47 tag. */
+    const inventoryOf = (lang) =>
+        lang === undefined ? undefined : (
+            (ctx.romanInventories?.get(lang) ?? ctx.romanInventories?.get(lang.toLowerCase()))
+        );
+
+    /** Check visible source before mapping or lexicon-native replacement. */
+    const roman = (parts, detail) => {
+        const inventory = inventoryOf(detail.run.lang);
+        if (!inventory) return;
+        if (!inventory.characters) {
+            report(
+                { line: detail.run.line, column: detail.run.column },
+                `the language note for \`${inventory.language}\` must declare \`data.roman\``,
+            );
+            return;
+        }
+        for (const [from, to] of parts) {
+            let base = from;
+            for (const line of text.slice(from, to).split("\n")) {
+                // A terminal unescaped backslash is a Markdown line break.
+                const breakMark =
+                    /(?<!\\)(?:\\\\)*\\$/.test(line) && text[base + line.length] === "\n";
+                const plain = unescapeRoman(breakMark ? line.slice(0, -1) : line);
+                for (const problem of romanTextProblems(plain.text, inventory, (char) => {
+                    const point = char.codePointAt(0);
+                    return (
+                        detail.run.nativefont === true &&
+                        isSettingScriptCodePoint(point) &&
+                        detail.face?.draws.has(point)
+                    );
+                }))
+                    report(
+                        positionOf(starts, base + (plain.offsets[problem.offset] ?? 0)),
+                        problem.message,
+                    );
+                base += line.length + 1;
+            }
+        }
+    };
+
     /**
      * Report each word of a mapped run that is not a word of its language, once
      * per run, at its first character.
@@ -1515,6 +1576,7 @@ function analyseRuns(source, ctx, syntax) {
         };
         runs.push(run);
         const plain =
+            inventoryOf(lang) !== undefined ||
             font !== undefined ||
             map !== undefined ||
             (lang !== undefined &&
@@ -1577,15 +1639,18 @@ function analyseRuns(source, ctx, syntax) {
             }
             if (plain && errors.length === before)
                 plainInline(inline, from, marking, detail, detail.holes);
-            if (named && errors.length === before) {
+            if (errors.length === before) {
                 const parts = outsideDelimiters(
                     outsideHoles(from, to, detail.holes),
                     detail.emphasis,
                 );
-                lexical(parts, detail);
-                capitals(parts, detail);
-                writings(parts, detail);
-                covered(parts, detail);
+                roman(parts, detail);
+                if (named) {
+                    lexical(parts, detail);
+                    capitals(parts, detail);
+                    writings(parts, detail);
+                    covered(parts, detail);
+                }
             }
             continue;
         }
@@ -1647,15 +1712,30 @@ function analyseRuns(source, ctx, syntax) {
             for (let line = first; line < last; line++)
                 plainInline(lines[line], starts[line], marking, detail, detail.holes);
         }
-        if (named && errors.length === before) {
+        if (errors.length === before) {
             const parts = outsideDelimiters(outsideHoles(from, to, detail.holes), detail.emphasis);
-            lexical(parts, detail);
-            capitals(parts, detail);
-            writings(parts, detail);
-            covered(parts, detail);
+            roman(parts, detail);
+            if (named) {
+                lexical(parts, detail);
+                capitals(parts, detail);
+                writings(parts, detail);
+                covered(parts, detail);
+            }
         }
     }
 
+    for (const reference of rawReferences) {
+        const font = reference.construct.keys.font ?? ctx.writtenIn?.get(reference.lang)?.font;
+        roman([[reference.from, reference.to]], {
+            run: {
+                lang: reference.lang,
+                nativefont: native(reference.construct),
+                ...reference.where,
+            },
+            face: font === undefined ? undefined : faces.get(font),
+        });
+    }
+
     const order = (a, b) => a.line - b.line || a.column - b.column;
     runs.sort(order);
     details.sort((a, b) => order(a.run, b.run));

package/engine/index.mjs

@@ -227,6 +227,9 @@ export * as contentLint from "./content-lint.mjs";
 
 /** The charset authored content is held to, so a book can choose its face. */
 export * as contentCharset from "./content-charset.mjs";
+
+/** Exact permitted Roman source characters for configured languages. */
+export * as romanCharacters from "./roman-characters.mjs";
 export * as pathCharset from "./path-charset.mjs";
 
 /** Naming an interface icon in a note, without drawing one there. */

package/engine/language-data.mjs

@@ -73,6 +73,7 @@ import {
 import { LANGUAGE_SUBTYPE } from "./word-terms.mjs";
 import { WORD_CLASS_BASES } from "./word-classes.mjs";
 import { nearest } from "./near-miss.mjs";
+import { romanInventoryProblems } from "./roman-characters.mjs";
 
 /** The bases a frame's `class` names. */
 const CLASS_BASES = new Set(WORD_CLASS_BASES.map((item) => item.token));
@@ -614,7 +615,9 @@ export function checkLanguageData(note, { index, types } = {}) {
             ),
         );
 
-    const findings = [];
+    const findings = romanInventoryProblems(data.roman).map((message) =>
+        finding(["data", "roman"], "error", message),
+    );
 
     // Only the shape of a supplied declaration: no word is compared with it.
     const grammar = isMap(data.grammar) ? data.grammar : {};

package/engine/language-terms.mjs

@@ -30,6 +30,7 @@
 
 /** The `data` keys a language note states its sounds, names and history in. */
 export const LANGUAGE_DATA_KEYS = Object.freeze([
+    "roman",
     "tongues",
     "register",
     "retired",
@@ -1889,6 +1890,15 @@ const GRAMMAR_FIELDS = Object.freeze([
  * @type {readonly object[]}
  */
 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",
+        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.",
+    }),
     Object.freeze({
         name: "grammar",
         kind: "map",

package/engine/map-lexicon.mjs

@@ -330,7 +330,18 @@ export function languageNoteFindings(config, records) {
     }
     const findings = [];
     for (const [name, { record }] of languageNotes(languages, contentPackage, records)) {
-        if (record) continue;
+        if (record) {
+            if (typeof record.data?.roman !== "string")
+                findings.push({
+                    file: configFile ?? CONFIG,
+                    ...(text ?
+                        positionOfYamlPath(text, ["languages", name, "note"], { key: true })
+                    :   {}),
+                    severity: "error",
+                    message: `the language note named by \`languages.${name}.note\` must declare \`data.roman\``,
+                });
+            continue;
+        }
         findings.push({
             file: configFile ?? CONFIG,
             ...(text ? positionOfYamlPath(text, ["languages", name, "note"], { key: true }) : {}),

package/engine/roman-characters.mjs

@@ -0,0 +1,113 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/** A language's exact Roman source characters, before any script conversion. */
+
+/** Unicode graphemes keep every canonically composing sequence together. */
+const graphemes = new Intl.Segmenter(undefined, { granularity: "grapheme" });
+
+/** A code point as the author sees it in a finding. */
+const codeName = (char) => `U+${char.codePointAt(0).toString(16).toUpperCase().padStart(4, "0")}`;
+
+/**
+ * Semantic problems in a supplied inventory. Shape belongs to the vocabulary.
+ * An empty string explicitly declares no written characters.
+ * @param {unknown} value - The authored `data.roman`.
+ * @returns {string[]} Findings at that field.
+ */
+export function romanInventoryProblems(value) {
+    if (typeof value !== "string") return [];
+    const problems = [];
+    if (value !== value.normalize("NFC"))
+        problems.push(
+            "`data.roman` must use NFC spelling; write precomposed accented letters where available",
+        );
+    if (/\s/u.test(value))
+        problems.push(
+            "`data.roman` lists characters without whitespace; spaces and line breaks are structural",
+        );
+    if (/[\p{Cc}\p{Cf}\p{Cs}]/u.test(value))
+        problems.push("`data.roman` contains a control, format or unpaired surrogate character");
+    const seen = new Set();
+    const repeated = new Set();
+    for (const char of value) {
+        if (seen.has(char)) repeated.add(char);
+        seen.add(char);
+    }
+    if (repeated.size)
+        problems.push(
+            `\`data.roman\` repeats ${[...repeated].map((char) => `\`${char}\` (${codeName(char)})`).join(", ")}; list each character once`,
+        );
+    return problems;
+}
+
+/**
+ * @typedef {object} RomanInventory
+ * @property {string} language - The configured language name.
+ * @property {ReadonlySet<string>|undefined} characters - Exact code points, absent for a missing declaration.
+ */
+
+/**
+ * Each configured language note's own inventory, by alias and BCP 47 tag.
+ * Language-family ancestry does not supply an inventory. Unassociated external
+ * tags have no entry and keep their ordinary behavior.
+ * @param {ReadonlyMap<string, Record<string, any>>} records - Configured language notes.
+ * @param {Readonly<Record<string, {tag: string}>>} languages - Language configuration.
+ * @returns {Map<string, RomanInventory>}
+ */
+export function romanInventoriesOf(records, languages = {}) {
+    const out = new Map();
+    for (const [language, record] of records) {
+        const value = record.data?.roman;
+        const inventory = Object.freeze({
+            language,
+            characters: typeof value === "string" ? new Set(value) : undefined,
+        });
+        out.set(language, inventory);
+        const tag = languages[language]?.tag;
+        if (typeof tag === "string") out.set(tag.toLowerCase(), inventory);
+    }
+    return out;
+}
+
+/**
+ * Invalid source characters, retaining offsets in the supplied unescaped text.
+ * No punctuation, case or normalization repair is performed.
+ * @param {string} text - Visible Roman source.
+ * @param {RomanInventory} inventory - Its language's declared characters.
+ * @param {(char: string) => boolean} [native] - Whether a directly typed native sign is drawn in the selected native face.
+ * @returns {Array<{offset: number, message: string}>}
+ */
+export function romanTextProblems(text, inventory, native = () => false) {
+    const out = [];
+    if (!inventory.characters) return out;
+    for (const { segment: cluster, index } of graphemes.segment(text)) {
+        let offset = index;
+        if (cluster !== cluster.normalize("NFC")) {
+            out.push({
+                offset,
+                message: `\`${cluster}\` is not NFC spelling in \`${inventory.language}\`; write \`${cluster.normalize("NFC")}\``,
+            });
+            continue;
+        }
+        for (const char of cluster) {
+            if (!/[ \t\r\n]/u.test(char) && !inventory.characters.has(char) && !native(char))
+                out.push({
+                    offset,
+                    message: `\`${char}\` (${codeName(char)}) is not in \`${inventory.language}\`'s \`data.roman\` inventory`,
+                });
+            offset += char.length;
+        }
+    }
+    return out;
+}

package/package.json

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

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

@@ -9,6 +9,14 @@
  * @returns {boolean} Whether Tier 1 admits it.
  */
 export function isLetterTier(cp: number): boolean;
+/**
+ * Whether a code point belongs to a declared setting-script encoding block.
+ * This identifies native input independently of a language's Roman inventory;
+ * a selected native face must still draw the individual character.
+ * @param {number} cp - A Unicode code point.
+ * @returns {boolean}
+ */
+export function isSettingScriptCodePoint(cp: number): boolean;
 /**
  * Whether the charset admits a code point anywhere in a note.
  *

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

@@ -254,6 +254,11 @@ export type RunContext = {
      * {@link module :engine/verse-metre.metreBooksFromRecords}.
      */
     metreBooks?: ReadonlyMap<string, import("./verse-metre.mjs").MetreBook> | undefined;
+    /**
+     * -
+     * Exact Roman source inventories by configured alias and BCP 47 tag.
+     */
+    romanInventories?: ReadonlyMap<string, import("./roman-characters.mjs").RomanInventory> | undefined;
     /**
      * -
      * Each face's emphasis conventions, from the script notes, by

package/types/engine/index.d.mts

@@ -65,6 +65,7 @@ export * as previewIndex from "./preview-index.mjs";
 export * as contentRender from "./content-render.mjs";
 export * as contentLint from "./content-lint.mjs";
 export * as contentCharset from "./content-charset.mjs";
+export * as romanCharacters from "./roman-characters.mjs";
 export * as pathCharset from "./path-charset.mjs";
 export * as contentIcons from "./content-icons.mjs";
 export * as contentHtml from "./content-html.mjs";

package/types/engine/roman-characters.d.mts

@@ -0,0 +1,45 @@
+/**
+ * Semantic problems in a supplied inventory. Shape belongs to the vocabulary.
+ * An empty string explicitly declares no written characters.
+ * @param {unknown} value - The authored `data.roman`.
+ * @returns {string[]} Findings at that field.
+ */
+export function romanInventoryProblems(value: unknown): string[];
+/**
+ * @typedef {object} RomanInventory
+ * @property {string} language - The configured language name.
+ * @property {ReadonlySet<string>|undefined} characters - Exact code points, absent for a missing declaration.
+ */
+/**
+ * Each configured language note's own inventory, by alias and BCP 47 tag.
+ * Language-family ancestry does not supply an inventory. Unassociated external
+ * tags have no entry and keep their ordinary behavior.
+ * @param {ReadonlyMap<string, Record<string, any>>} records - Configured language notes.
+ * @param {Readonly<Record<string, {tag: string}>>} languages - Language configuration.
+ * @returns {Map<string, RomanInventory>}
+ */
+export function romanInventoriesOf(records: ReadonlyMap<string, Record<string, any>>, languages?: Readonly<Record<string, {
+    tag: string;
+}>>): Map<string, RomanInventory>;
+/**
+ * Invalid source characters, retaining offsets in the supplied unescaped text.
+ * No punctuation, case or normalization repair is performed.
+ * @param {string} text - Visible Roman source.
+ * @param {RomanInventory} inventory - Its language's declared characters.
+ * @param {(char: string) => boolean} [native] - Whether a directly typed native sign is drawn in the selected native face.
+ * @returns {Array<{offset: number, message: string}>}
+ */
+export function romanTextProblems(text: string, inventory: RomanInventory, native?: (char: string) => boolean): Array<{
+    offset: number;
+    message: string;
+}>;
+export type RomanInventory = {
+    /**
+     * - The configured language name.
+     */
+    language: string;
+    /**
+     * - Exact code points, absent for a missing declaration.
+     */
+    characters: ReadonlySet<string> | undefined;
+};