@heroiclands/package-build 24.0.1 → 24.0.2

package/engine/language-rows.mjs

@@ -309,11 +309,14 @@ function languagesOf(records) {
  * @param {string} [options.prefix] - The prefix of a key sharing an identity
  *   column's name.
  * @param {readonly string[]} [options.lists] - The keys always set as lists.
+ * @param {(records: Iterable<Record<string, any>>) => Array<[string, Record<string, any>]>} [options.sources] -
+ *   The records stating the list, with their Addresses; the language records
+ *   where unstated.
  * @returns {object[]} One row per entry, in record then entry order.
  */
-function listRows(records, read, keys, { prefix = "", lists = [] } = {}) {
+function listRows(records, read, keys, { prefix = "", lists = [], sources = languagesOf } = {}) {
     const rows = [];
-    for (const [language, record] of languagesOf(records)) {
+    for (const [language, record] of sources(records)) {
         const entries = read(isMap(record.data) ? record.data : {});
         if (!Array.isArray(entries)) continue;
         entries.forEach((entry, position) => {
@@ -328,6 +331,24 @@ function listRows(records, read, keys, { prefix = "", lists = [] } = {}) {
     return rows;
 }
 
+/**
+ * Each record stating letters and marks, with its Address: every language
+ * record, and every `doc` record whose `data.sounds` is a spelling guide's.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {Array<[string, Record<string, any>]>}
+ */
+function soundSourcesOf(records) {
+    const list = [...records];
+    const out = languagesOf(list);
+    for (const record of list) {
+        if (record?.type !== "doc" || record.documents || !isMap(record.data?.sounds)) continue;
+        const address = noteAddressOf(record);
+        if (address) out.push([address, record]);
+    }
+    return out;
+}
+
 /** A language's `data.sounds`, or an empty map. */
 const soundsOf = (data) => (isMap(data.sounds) ? data.sounds : {});
 
@@ -494,8 +515,8 @@ export function scopeRows(records) {
 }
 
 /**
- * The `letters` rows: one per `data.sounds.letters` entry, `letters` and
- * `tongue` lists.
+ * The `letters` rows: one per `data.sounds.letters` entry of a language note
+ * or a spelling guide, `letters` and `tongue` lists.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}
@@ -503,6 +524,7 @@ export function scopeRows(records) {
 export function letterRows(records) {
     return listRows(records, (data) => soundsOf(data).letters, LETTER_KEYS, {
         lists: ["letters", "tongue"],
+        sources: soundSourcesOf,
     });
 }
 
@@ -875,13 +897,17 @@ export function joinRows(records) {
 }
 
 /**
- * The `marks` rows: one per `data.sounds.marks` entry.
+ * The `marks` rows: one per `data.sounds.marks` entry of a language note or a
+ * spelling guide.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}
  */
 export function markRows(records) {
-    return listRows(records, (data) => soundsOf(data).marks, MARK_KEYS, { lists: ["letters"] });
+    return listRows(records, (data) => soundsOf(data).marks, MARK_KEYS, {
+        lists: ["letters"],
+        sources: soundSourcesOf,
+    });
 }
 
 /**

package/engine/language-terms.mjs

@@ -130,7 +130,7 @@ export const CLUSTER_USES = Object.freeze(["common", "sparing"]);
 export const STRESS_TWO = Object.freeze(["first", "last"]);
 
 /** The syllable a word of three or more stresses, counted from its end. */
-export const STRESS_LONGER = Object.freeze(["antepenultimate", "penultimate", "final"]);
+export const STRESS_LONGER = Object.freeze(["first", "antepenultimate", "penultimate", "final"]);
 
 /**
  * The diacritics that mark a stress the rule would not choose, with the
@@ -377,13 +377,20 @@ export const LETTER_FIELDS = Object.freeze([
         shape: "a string, such as `lips` or `tongue-tip`",
         describe: "Where in the mouth they are made.",
     }),
+    Object.freeze({
+        name: "ipa",
+        kind: "string",
+        shape: "a string in the International Phonetic Alphabet, such as `ʃ`",
+        describe: "The sounds they write, in the International Phonetic Alphabet.",
+    }),
     Object.freeze({
         name: "tongue",
         kind: "string-or-list",
-        shape: "a tag, or a list of them",
+        shape: "a tag or a language note's Address, or a list of them",
         entries: STRINGS,
         describe:
-            "The tongues that write them, as tags `data.tongues` declares; every one where absent.",
+            "The tongues that write them, each a tag `data.tongues` declares or the Address of a " +
+            "language note; every one where absent. A `doc` note's rows name language notes only.",
     }),
 ]);
 
@@ -529,6 +536,12 @@ export const FINAL_FIELDS = Object.freeze([
         shape: "a string",
         describe: "What it sounds like.",
     }),
+    Object.freeze({
+        name: "ipa",
+        kind: "string",
+        shape: "a string in the International Phonetic Alphabet, such as `ʃ`",
+        describe: "Its sound, in the International Phonetic Alphabet.",
+    }),
 ]);
 
 /**
@@ -718,7 +731,8 @@ export const STRESS_FIELDS = Object.freeze([
         required: true,
         allowed: STRESS_LONGER,
         shape: `one of ${STRESS_LONGER.join(", ")}`,
-        describe: "The stressed syllable of a word of three or more, counted from its end.",
+        describe:
+            "The stressed syllable of a word of three or more: `first`, or counted from its end.",
     }),
     Object.freeze({
         name: "mark",
@@ -914,10 +928,10 @@ export const SOUND_FIELDS = Object.freeze([
     Object.freeze({
         name: "letters",
         kind: "list",
-        shape: "list of `{ letters, kind, like, tongue? }`",
+        shape: "list of `{ letters, kind, like?, place?, ipa?, tongue? }`",
         entries: Object.freeze({
             kind: "map",
-            shape: "a map — `{ letters, kind, like, tongue? }`",
+            shape: "a map — `{ letters, kind, like?, place?, ipa?, tongue? }`",
             fields: LETTER_FIELDS,
         }),
         describe: "The letters the language writes, and the sounds they stand for.",
@@ -950,10 +964,10 @@ export const SOUND_FIELDS = Object.freeze([
     Object.freeze({
         name: "finals",
         kind: "list",
-        shape: "list of `{ final, like }`",
+        shape: "list of `{ final, like, ipa? }`",
         entries: Object.freeze({
             kind: "map",
-            shape: "a map — `{ final, like }`",
+            shape: "a map — `{ final, like, ipa? }`",
             fields: FINAL_FIELDS,
         }),
         describe: "The syllable finals, for a language whose syllables are parsed by them.",
@@ -1047,6 +1061,16 @@ export const SOUND_FIELDS = Object.freeze([
     }),
 ]);
 
+/**
+ * The keys of a spelling guide's `data.sounds`: a `doc` note stating the
+ * letters and marks every tongue of a setting is written by.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const GUIDE_SOUND_FIELDS = Object.freeze(
+    SOUND_FIELDS.filter((field) => field.name === "letters" || field.name === "marks"),
+);
+
 /**
  * The keys of one `data.soundChanges` entry.
  *

package/engine/map-lexicon.mjs

@@ -55,6 +55,7 @@ import { positionOfFrontmatterPath, positionOfYamlPath } from "./diagnostics.mjs
 import { isNoteRecord } from "./index-records.mjs";
 import { nearest } from "./near-miss.mjs";
 import { WRITTEN_ENDINGS } from "./language-terms.mjs";
+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";
@@ -386,14 +387,37 @@ export function fontProblem(map, font) {
 }
 
 /**
- * The mapping a command uses, or what is wrong with what it was given. A map
- * listing one face defaults to it; one listing more needs `font`.
+ * The mapping a command uses, or what is wrong with what it was given. The
+ * language's `data.writtenIn` fills the map and the face it leaves out, as it
+ * fills a run's; after that, a map listing one face defaults to it, and one
+ * listing more needs `font`.
  *
  * @param {object} ctx - The run context.
- * @param {{map: string, font?: string, lang?: string}} keys - What was asked for.
+ * @param {{map?: string, font?: string, lang?: string}} keys - What was asked for.
  * @returns {{mapping: Mapping}|{problem: string, about: "map"|"lang"|"font"}} The mapping or the problem.
  */
-function commandMapping(ctx, { map, font, lang }) {
+function commandMapping(ctx, keys) {
+    const { lang } = keys;
+    const filled = fromWrittenIn(keys, ctx?.writtenIn, ctx?.maps);
+    const map = keys.map ?? filled.map;
+    const font = keys.font ?? filled.font;
+    if (map === undefined) {
+        if (lang !== undefined && !Object.hasOwn(ctx?.languages ?? {}, lang)) {
+            const near = nearest(lang, Object.keys(ctx?.languages ?? {}));
+            return {
+                about: "lang",
+                problem:
+                    `\`${lang}\` is not a declared language (\`languages\` in ${CONFIG})` +
+                    (near ? `; did you mean \`${near}\`?` : ""),
+            };
+        }
+        return {
+            about: "map",
+            problem:
+                `\`${lang}\` names no script: its note states no \`data.writtenIn\`, so name a ` +
+                "map with `--map`",
+        };
+    }
     const textMap = ctx?.maps?.get(map);
     if (!textMap) {
         const names = [...(ctx?.maps?.keys() ?? [])];
@@ -543,8 +567,9 @@ export function transliterate(ctx, keys, text) {
  * writing, the signs a run writes directly for that sense.
  *
  * @param {object} ctx - The run context.
- * @param {{lang: string, map: string, font?: string, derived?: boolean}} keys -
- *   The language, the map, the face, and whether to list derived forms.
+ * @param {{lang: string, map?: string, font?: string, derived?: boolean}} keys -
+ *   The language, the map, the face, and whether to list derived forms. A map
+ *   or a face left out is the one the language's `data.writtenIn` names.
  * @returns {{entries: Array<{form: string, native: string, exception?: boolean, source?: "own"|"parts"|"none", ambiguous?: true, class: string|null, gloss: string|null, from?: string}>}|{problem: string, about: string}}
  *   The words in `data.words` order, then any derived forms, or the problem.
  */

package/engine/note-vocabulary.mjs

@@ -139,8 +139,8 @@ import {
     checkLanguageWords,
 } from "./language-words.mjs";
 import { checkGlossary } from "./glossary-entries.mjs";
-import { LANGUAGE_DATA_FIELDS } from "./language-terms.mjs";
-import { checkLanguageData } from "./language-data.mjs";
+import { GUIDE_SOUND_FIELDS, LANGUAGE_DATA_FIELDS } from "./language-terms.mjs";
+import { checkGuideSounds, checkLanguageData } from "./language-data.mjs";
 import { checkAffiliationReach } from "./culture-reach.mjs";
 import { checkLanguageNames, requiredGivenGenders } from "./language-names.mjs";
 import { SOCIAL_TIES, SOCIAL_TIE_TARGET_TYPES } from "./social-tie-terms.mjs";
@@ -163,7 +163,12 @@ 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 { EMPHASIS_CONVENTIONS, LANGUAGE_EMPHASES } from "./script-emphasis-terms.mjs";
+import { WRITTEN_IN_KEY, checkWrittenIn } from "./written-in.mjs";
+import {
+    EMPHASIS_CONVENTIONS,
+    LANGUAGE_EMPHASES,
+    SCRIPT_DIRECTIONS,
+} from "./script-emphasis-terms.mjs";
 
 /**
  * One `data:` key a note type may carry.
@@ -2182,10 +2187,36 @@ 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 map and the face a run marked " +
+                    "with its name alone takes; a run's own `map=` or `font=` overrides it. Only a " +
+                    "skill of `subType: language` states it.",
+            },
             {
                 name: "script",
                 kind: "map",
-                shape: "a map — `{ fonts, emphasis, strongEmphasis? }`",
+                shape: "a map — `{ fonts, emphasis, strongEmphasis?, direction? }`",
                 check: checkScriptField,
                 fields: Object.freeze([
                     {
@@ -2220,10 +2251,20 @@ export const NOTE_VOCABULARY = Object.freeze({
                         allowed: EMPHASIS_CONVENTIONS,
                         describe: "The convention `**…**` takes instead of `emphasis`'s.",
                     },
+                    {
+                        name: "direction",
+                        kind: "string",
+                        shape: "`vertical-rl`",
+                        allowed: SCRIPT_DIRECTIONS,
+                        describe:
+                            "How the script is written: `vertical-rl` is columns, top to bottom, " +
+                            "read from the right, which a `scroll` fence sets. A script stating " +
+                            "none is written in lines.",
+                    },
                 ]),
                 describe:
-                    "A script note's faces and how it marks emphasis. Only a skill of " +
-                    "`subType: script` states it.",
+                    "A script note's faces, how it marks emphasis and the direction it is " +
+                    "written in. Only a skill of `subType: script` states it.",
             },
         ]),
     }),
@@ -2323,6 +2364,17 @@ export const NOTE_VOCABULARY = Object.freeze({
                     "The culture a setting guide introduces, as a culture lore note. " +
                     "Required on `settingguide`; no other subType states it.",
             },
+            {
+                name: "sounds",
+                kind: "map",
+                shape: "a map — `{ letters?, marks? }`",
+                fields: GUIDE_SOUND_FIELDS,
+                check: checkGuideSounds,
+                describe:
+                    "A spelling guide's letters and the marks written on them, for every " +
+                    "tongue of the setting: each letter row's `tongue` names the language notes " +
+                    "that write it.",
+            },
             {
                 name: "map",
                 kind: "map",

package/engine/pdf-fonts.mjs

@@ -55,7 +55,7 @@ import { familyOf } from "./content-icons.mjs";
  * @param {Buffer} buf - The font file.
  * @returns {Map<string, {offset: number, length: number}>} Its table directory.
  */
-function tableDirectory(buf) {
+export function tableDirectory(buf) {
     const tables = new Map();
     if (buf.length < 12) return tables;
     // A TrueType collection points at its first font; a bare font starts at 0.

package/engine/pdf-render.mjs

@@ -14,10 +14,11 @@
 /**
  * A note's markdown, and a document plan, rendered as Typst source.
  *
- * **This module emits text and reads nothing.** It takes markdown and a plan and
- * returns a `.typ` document; the filesystem, the note bodies and the compiler
- * that turns the result into a PDF all live in
- * {@link module:engine/pdf-build}. That split is what lets the outline, the
+ * **This module emits text and reads nothing but a face's outlines.** It takes
+ * markdown and a plan and returns a `.typ` document; the filesystem, the note
+ * bodies and the compiler that turns the result into a PDF all live in
+ * {@link module:engine/pdf-build}. The one file it reads is the TrueType face a
+ * `scroll` fence is drawn from, through {@link module:engine/font-outlines}. That split is what lets the outline, the
  * table of contents, every anchor and every link destination be asserted in a
  * unit test with no renderer installed — which is most of what a book has to
  * get right, and all of what a test can check without eyes.
@@ -95,6 +96,8 @@ import {
     verseStanzas,
 } from "./content-verse.mjs";
 import { matchAllOutsideCode, replaceOutsideCode } from "./code-fences.mjs";
+import { panelRoman, scanScrolls, scrollPanels, scrollParagraphs } from "./content-scroll.mjs";
+import { BOOK_INK, BOOK_RUBRIC, fontOutlines, scrollPanelSvg } from "./font-outlines.mjs";
 import { HTML_TAG, htmlMessage } from "./content-html.mjs";
 import { EXPRESSION } from "./markdown-expressions.mjs";
 import { inlineText } from "./name-markup.mjs";
@@ -498,11 +501,12 @@ export function markdownToTypst(markdown, opts = {}) {
     // is an offset into *this* string, and the renderer below walks slices of it.
     if (!opts.nested) reportUnrenderable(authored, definitions, opts, given);
     // Text marked with a language, a font or a map is rewritten once, ahead of
-    // every other pass, line for line; the nested calls below read the result.
-    const source =
-        opts.nested ? authored : (
-            renderRuns(authored, opts.runs, undefined, { target: "book" }).markdown
-        );
+    // every other pass, line for line; the nested calls below read the result,
+    // and the scroll fences' layouts the rewrite returns.
+    const marked =
+        opts.nested ? undefined : renderRuns(authored, opts.runs, undefined, { target: "book" });
+    const source = marked ? marked.markdown : authored;
+    if (marked) sharedOptions.scrolls = marked.scrolls;
     // One map for the whole body, not one per block: a heading inside a
     // blockquote or a list item shares the entry's anchor namespace with every
     // other heading in the same body, because `sectionLabel` scopes by entry
@@ -522,6 +526,7 @@ export function markdownToTypst(markdown, opts = {}) {
         seen: new Map(),
         footnoteState,
         footnotePrefix: opts.footnotePrefix ?? `footnote-${slugify(anchorPrefix || "body")}`,
+        scrolls: marked?.scrolls ?? opts.scrolls ?? new Map(),
     };
     // A withheld section is set in the box a `:::secret` is set in, and its
     // heading is set inside it: a printed page honours no reader permission, so
@@ -752,6 +757,10 @@ function renderBlock(tokens, i, out, ctx) {
         }
         case "fence":
         case "code_block": {
+            if (token.type === "fence" && /^scroll(?:\s|$)/.test(token.info?.trim() || "")) {
+                out.push(scrollBlock(token, ctx));
+                return 1;
+            }
             if (token.type === "fence" && /^verse(?:\s|$)/.test(token.info?.trim() || "")) {
                 const opening = `${token.markup}${token.info}`;
                 const poem = scanVerse(`${opening}\n${token.content}${token.markup}`).blocks[0];
@@ -1199,6 +1208,38 @@ function padCells(cells, columns) {
     return padded.map((c) => `[${c}]`).join(", ");
 }
 
+/**
+ * A `scroll` fence as the book sets it: Typst has no vertical writing, so each
+ * panel of at most `rows` × `cols` characters is an image drawn from the
+ * face's outlines, its roman text as alt text. The panels sit in a paragraph
+ * set right to left, so they are read from the right and wrap to the next
+ * line where the measure ends; without `cols`, each column is a panel, and as
+ * many columns sit side by side as fit. A fence the rewrite of marked text did
+ * not set, or whose face has no TrueType file, is set as code.
+ *
+ * @param {object} token - The fence token.
+ * @param {object} ctx - Render context, holding the scroll layouts.
+ * @returns {string} Typst markup.
+ */
+function scrollBlock(token, ctx) {
+    const scroll = scanScrolls(`${token.markup}${token.info}\n${token.content}${token.markup}`)
+        .blocks[0];
+    const layout = ctx.scrolls?.get(scrollParagraphs(token.content.split("\n")).join("\n\n"));
+    if (!scroll || scroll.invalid || !layout?.face?.file)
+        return rawBlock(token.content, token.info?.trim() || "");
+    const outlines = fontOutlines(layout.face.file);
+    const { rows, panels } = scrollPanels(layout.paragraphs, scroll);
+    const boxes = panels.map(
+        (panel) =>
+            `#box(image(bytes("${escapeTypstString(scrollPanelSvg(panel, rows, outlines))}"), ` +
+            `format: "svg", height: ${rows}em, alt: "${escapeTypstString(panelRoman(panel, layout.paragraphs))}"))`,
+    );
+    // A zero-width space lets a line break between two columns and adds no
+    // width; panels of several columns are kept a column gap apart.
+    const between = scroll.cols === undefined ? "\u200B" : "#h(1em, weak: true) ";
+    return `\n#block(width: 100%)[#set text(dir: rtl)\n${boxes.join(between)}\n]\n\n`;
+}
+
 /**
  * A fenced block as Typst raw text.
  *
@@ -1944,10 +1985,10 @@ export function bookTypstPreamble(runs = {}, families = {}) {
         // The title sets short of the measure, so a plate's last line does not
         // run to the trimmed edge of the paper.
         "#let book-title-measure = book-text-width - 2.5cm",
-        '#let book-ink = rgb("#241f1a")',
+        `#let book-ink = rgb("${BOOK_INK}")`,
         // A rubric script's emphasis: a vermilion that holds 4.5:1 on the paper
         // and stays apart from the ink in lightness.
-        '#let book-rubric = rgb("#9c281b")',
+        `#let book-rubric = rgb("${BOOK_RUBRIC}")`,
         '#let book-paper = rgb("#f4efe4")',
         '#let book-accent = rgb("#7c3b1e")',
         '#let book-head = rgb("#5e2b14")',

package/engine/run-rows.mjs

@@ -17,6 +17,10 @@
  * column value and none is a key, so two notes writing one tag in different
  * case are two rows. Documentation records and assets contribute no rows.
  *
+ * A run's `font` and `map` are the ones it is set with: its own, else those of
+ * the div or fence around it, else those its language's note names in
+ * `data.writtenIn`, filled by {@link fillWrittenIn} once every record exists.
+ *
  * @module
  */
 
@@ -24,6 +28,9 @@ import { canonicalKey, readCanonicalKey } from "./address.mjs";
 import { encodeAddresses } from "./address-values.mjs";
 import { isNoteRecord } from "./index-records.mjs";
 import { scanRuns } from "./content-scripts.mjs";
+import { languageRecordsByName } from "./map-lexicon.mjs";
+import { mapsFromRecords } from "./text-maps.mjs";
+import { fromWrittenIn, writtenInOf } from "./written-in.mjs";
 
 /** Every column of the `runs` relation, in order. */
 export const RUN_COLUMNS = Object.freeze([
@@ -41,12 +48,14 @@ export const RUN_COLUMNS = Object.freeze([
  * One run as an index record carries it.
  *
  * @typedef {object} RecordRun
- * @property {"span"|"block"|"verse"} kind - The construct.
+ * @property {"span"|"block"|"verse"|"scroll"} kind - The construct.
  * @property {string|null} lang - The language it is set in, as written: its
  *   own `lang=`, else the one the div or fence around it states.
  * @property {string|null} tag - The BCP 47 tag it resolves to, or null.
- * @property {string|null} font - Its font, as written and inherited the same way.
- * @property {string|null} map - Its map, as written and inherited the same way.
+ * @property {string|null} font - Its font, as written and inherited the same
+ *   way, else its language's script's.
+ * @property {string|null} map - Its map, as written and inherited the same way,
+ *   else its language's script's.
  * @property {number} line - 1-based file line of its opening.
  * @property {number} column - 1-based UTF-16 file column of its opening.
  */
@@ -80,6 +89,39 @@ export function recordRuns(body, { context, bodyLine = 1, bodyColumn = 1, syntax
     }));
 }
 
+/**
+ * Give every recorded run the map and face its language's note names in
+ * `data.writtenIn`, where the run leaves them unstated, as a run is set. Read
+ * once every record exists, since a run's language note may be recorded after
+ * the note that marks it.
+ *
+ * @param {Record<string, any>[]} records - The package's index records; each
+ *   note record's `runs` is updated in place.
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
+ *   The configured languages, whose `note` names each language note.
+ */
+export function fillWrittenIn(records, config) {
+    const maps = mapsFromRecords(records);
+    const scripts = writtenInOf(languageRecordsByName(records, config), maps);
+    if (!scripts.size) return;
+    for (const record of records) {
+        if (!record || !isNoteRecord(record) || !Array.isArray(record.runs)) continue;
+        for (const run of record.runs) {
+            const filled = fromWrittenIn(
+                {
+                    lang: run.lang ?? undefined,
+                    map: run.map ?? undefined,
+                    font: run.font ?? undefined,
+                },
+                scripts,
+                maps,
+            );
+            if (filled.map !== undefined) run.map = filled.map;
+            if (filled.font !== undefined) run.font = filled.font;
+        }
+    }
+}
+
 /**
  * The containing page's NOTE identity.
  *

package/engine/script-direction.mjs

@@ -0,0 +1,67 @@
+/*
+ * 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
+ */
+
+/**
+ * **The direction a script is written in.** A script note states it beside its
+ * faces:
+ *
+ * ```yaml
+ * data:
+ *   script:
+ *     fonts: [teng-chou]
+ *     emphasis: rubric
+ *     direction: vertical-rl
+ * ```
+ *
+ * `vertical-rl` is a script written in columns, top to bottom, the columns
+ * read from the right. A script that states no direction is written in lines.
+ * Markup never states a direction: a `scroll` fence takes its script's, and is
+ * refused in a script written in lines; see
+ * {@link module:engine/content-scroll}.
+ *
+ * @module
+ */
+
+import { isNoteRecord } from "./index-records.mjs";
+import { SCRIPT_DIRECTIONS, SCRIPT_SUBTYPE } from "./script-emphasis-terms.mjs";
+
+export { SCRIPT_DIRECTIONS } from "./script-emphasis-terms.mjs";
+
+/**
+ * Each face's direction, from the script notes among the index records. The
+ * first note to list a face keeps it; a face whose note states no direction,
+ * or one the build does not know, is absent.
+ *
+ * @param {Iterable<Record<string, any>>|undefined} records - Index records.
+ * @returns {Map<string, "vertical-rl">} The directions, by face slug.
+ */
+export function directionsFromRecords(records) {
+    const out = new Map();
+    const listed = new Set();
+    for (const record of records ?? []) {
+        if (!record || !isNoteRecord(record)) continue;
+        if (
+            record.type !== "skill" ||
+            String(record.subType ?? "").toLowerCase() !== SCRIPT_SUBTYPE
+        )
+            continue;
+        const script = record.data?.script;
+        if (!script || typeof script !== "object" || !Array.isArray(script.fonts)) continue;
+        for (const slug of script.fonts) {
+            if (typeof slug !== "string" || listed.has(slug)) continue;
+            listed.add(slug);
+            if (SCRIPT_DIRECTIONS.includes(script.direction)) out.set(slug, script.direction);
+        }
+    }
+    return out;
+}

package/engine/script-emphasis-terms.mjs

@@ -12,9 +12,10 @@
  */
 
 /**
- * **The words a script note and a language note state emphasis by.** Read by
- * the vocabulary as it is declared, so this module imports nothing; the
- * checks and the conventions' use are in {@link module:engine/script-emphasis}.
+ * **The words a script note and a language note state emphasis and direction
+ * by.** Read by the vocabulary as it is declared, so this module imports
+ * nothing; the checks and the conventions' use are in
+ * {@link module:engine/script-emphasis} and {@link module:engine/script-direction}.
  *
  * @module
  */
@@ -34,5 +35,12 @@ export const EMPHASIS_CLASSES = Object.freeze({
  */
 export const LANGUAGE_EMPHASES = Object.freeze(["words", ...EMPHASIS_CONVENTIONS]);
 
+/**
+ * The directions a script states it is written in. `vertical-rl` is columns,
+ * top to bottom, read from the right; a script stating none is written in
+ * lines.
+ */
+export const SCRIPT_DIRECTIONS = Object.freeze(["vertical-rl"]);
+
 /** The `subType` of a script note. */
 export const SCRIPT_SUBTYPE = "script";