@heroiclands/package-build 24.0.1 → 24.0.3

package/engine/language-data.mjs

@@ -21,9 +21,11 @@
  * - no skill of another subType states these keys;
  * - a tongue tag is lowercase letters and digits, optionally closing on
  *   `:<tongue>`, and stands once; a tongue's `language` names a language note;
- * - every tag a register row or a letter row names is declared in
- *   `data.tongues`, `translation` apart: `exonym:vylari` is declared by
- *   `exonym:<tongue>`;
+ * - every tag a register row names is declared in `data.tongues`,
+ *   `translation` apart: `exonym:vylari` is declared by `exonym:<tongue>`;
+ * - every tongue a letter row names is such a tag or the Address of a
+ *   language note, and a spelling guide's, on a `doc` note, an Address (see
+ *   {@link checkGuideSounds});
  * - an edge stands once in `data.sounds.edges`;
  * - a sound stands once in each mutation of `data.sounds.mutations`;
  * - a cluster stands in one group of `data.sounds.clusters.groups`, and a
@@ -432,6 +434,153 @@ function checkParticiples(participles, affixes, finding) {
     return out;
 }
 
+/**
+ * The Address checks a note's data reads through, each finding located by
+ * `finding`.
+ *
+ * @param {object|undefined} index - The index; without `addressHit`, nothing
+ *   resolves and nothing is reported.
+ * @param {(path: Array<string|number>, severity: string, message: string, key?: boolean) => object} finding -
+ *   A finding at a path of the note's frontmatter.
+ * @returns {{resolve: Function, language: Function}} The checks.
+ */
+function resolvers(index, finding) {
+    /**
+     * The note an Address names, or a finding where it names none.
+     *
+     * @param {unknown} value - The Address as the note holds it.
+     * @param {Array<string|number>} path - Where it sits.
+     * @param {string|undefined} type - The type a bare shortcode defaults to.
+     * @param {boolean} [key] - Whether the Address is a map key.
+     * @returns {{target?: object, key?: string, finding?: object}}
+     */
+    function resolve(value, path, type, key = false) {
+        if (!index?.addressHit || value === undefined || value === null) return {};
+        const canonical = addressKeyOf(value, index, type);
+        if (!canonical)
+            return {
+                finding: finding(
+                    path,
+                    "error",
+                    `\`${label(path)}\` is not an Address: ${JSON.stringify(
+                        isAddressTuple(value) ? renderAddress(value) : value,
+                    )}`,
+                    key,
+                ),
+            };
+        const target = index.addressHit(canonical);
+        if (!target)
+            return {
+                finding: finding(
+                    path,
+                    "error",
+                    `\`${label(path)}\` names ${canonical}, which does not resolve in this ` +
+                        "package or its declared dependencies",
+                    key,
+                ),
+            };
+        return { target, key: canonical };
+    }
+
+    /** As {@link resolve}, and the target must be a language note. */
+    function language(value, path, key = false) {
+        const result = resolve(value, path, "skill", key);
+        if (result.finding) return [result.finding];
+        if (!result.target) return [];
+        const target = result.target.fm ?? result.target;
+        if (target.type === "skill" && target.subType === LANGUAGE_SUBTYPE) return [];
+        return [
+            finding(
+                path,
+                "error",
+                `\`${label(path)}\` names ${result.key}, which is not a skill whose subType is ` +
+                    "language",
+                key,
+            ),
+        ];
+    }
+
+    return { resolve, language };
+}
+
+/**
+ * The findings on each `tongue` of a note's `data.sounds.letters` rows. A value
+ * is a tag the note's `data.tongues` declares, or else the Address of a
+ * language note; a `doc` note declares no tags, so its rows name language
+ * notes only. Without an index no Address resolves: a language note's value
+ * that is not a declared tag is then a finding, and a guide's is not checked.
+ *
+ * @param {unknown} letters - The rows.
+ * @param {object} context
+ * @param {Set<string>|undefined} context.declared - The tags `data.tongues`
+ *   declares; `undefined` on a note that declares none.
+ * @param {object|undefined} context.index - The index Addresses resolve in.
+ * @param {(path: Array<string|number>, severity: string, message: string, key?: boolean) => object} context.finding -
+ *   A finding at a path of the note's frontmatter.
+ * @returns {object[]} The findings, each at its value.
+ */
+function letterTongueFindings(letters, { declared, index, finding }) {
+    const { resolve, language } = resolvers(index, finding);
+    const out = [];
+    listOf(letters).forEach((row, i) => {
+        if (!isMap(row) || row.tongue === undefined || row.tongue === null) return;
+        const at = ["data", "sounds", "letters", i, "tongue"];
+        const values = Array.isArray(row.tongue) ? row.tongue : [row.tongue];
+        values.forEach((value, j) => {
+            if (typeof value !== "string") return;
+            if (declared && tongueDeclared(value, declared)) return;
+            const path = Array.isArray(row.tongue) ? [...at, j] : at;
+            const resolved = resolve(value, path, "skill");
+            if (resolved.target) {
+                out.push(...language(value, path));
+                return;
+            }
+            if (declared)
+                out.push(
+                    finding(
+                        path,
+                        "error",
+                        `the tongue \`${value}\` is not declared in \`data.tongues\`` +
+                            (index?.addressHit ? " and names no language note" : ""),
+                    ),
+                );
+            else if (resolved.finding)
+                out.push(
+                    finding(
+                        path,
+                        "error",
+                        `\`${label(path)}\` names \`${value}\`, which is no language note's ` +
+                            "Address; a spelling guide names each tongue by its language note",
+                    ),
+                );
+        });
+    });
+    return out;
+}
+
+/**
+ * Check a `doc` note's `data.sounds`, a spelling guide's letters and marks:
+ * each letter row's `tongue` names language notes. The data-key check owns
+ * the keys, so a sound rule a guide does not state is refused there.
+ *
+ * @param {object} note - A `doc` note: `file`, `raw` and parsed `fm`.
+ * @param {object} [context]
+ * @param {object} [context.index] - The index, for whether an Address resolves.
+ * @returns {object[]} The findings.
+ */
+export function checkGuideSounds(note, { index } = {}) {
+    const sounds = note?.fm?.data?.sounds;
+    if (!isMap(sounds)) return [];
+    const raw = note.raw ?? "";
+    const finding = (path, severity, message, key = false) => ({
+        file: note.file,
+        ...positionOfFrontmatterPath(raw, path, { key }),
+        severity,
+        message,
+    });
+    return letterTongueFindings(sounds.letters, { declared: undefined, index, finding });
+}
+
 /**
  * Check a `skill` note's language data against what it means.
  *
@@ -542,60 +691,7 @@ export function checkLanguageData(note, { index, types } = {}) {
         ...checkAffixClasses(data.affixes, finding),
     );
 
-    /**
-     * The note an Address names, or a finding where it names none.
-     *
-     * @param {unknown} value - The Address as the note holds it.
-     * @param {Array<string|number>} path - Where it sits.
-     * @param {string|undefined} type - The type a bare shortcode defaults to.
-     * @param {boolean} [key] - Whether the Address is a map key.
-     * @returns {{target?: object, key?: string, finding?: object}}
-     */
-    function resolve(value, path, type, key = false) {
-        if (!index?.addressHit || value === undefined || value === null) return {};
-        const canonical = addressKeyOf(value, index, type);
-        if (!canonical)
-            return {
-                finding: finding(
-                    path,
-                    "error",
-                    `\`${label(path)}\` is not an Address: ${JSON.stringify(
-                        isAddressTuple(value) ? renderAddress(value) : value,
-                    )}`,
-                    key,
-                ),
-            };
-        const target = index.addressHit(canonical);
-        if (!target)
-            return {
-                finding: finding(
-                    path,
-                    "error",
-                    `\`${label(path)}\` names ${canonical}, which does not resolve in this ` +
-                        "package or its declared dependencies",
-                    key,
-                ),
-            };
-        return { target, key: canonical };
-    }
-
-    /** As {@link resolve}, and the target must be a language note. */
-    function language(value, path, key = false) {
-        const result = resolve(value, path, "skill", key);
-        if (result.finding) return [result.finding];
-        if (!result.target) return [];
-        const target = result.target.fm ?? result.target;
-        if (target.type === "skill" && target.subType === LANGUAGE_SUBTYPE) return [];
-        return [
-            finding(
-                path,
-                "error",
-                `\`${label(path)}\` names ${result.key}, which is not a skill whose subType is ` +
-                    "language",
-                key,
-            ),
-        ];
-    }
+    const { resolve, language } = resolvers(index, finding);
 
     // ── Tongues ──────────────────────────────────────────────────────────────
     const declared = new Set();
@@ -668,12 +764,7 @@ export function checkLanguageData(note, { index, types } = {}) {
 
     // ── Sounds ───────────────────────────────────────────────────────────────
     const sounds = isMap(data.sounds) ? data.sounds : {};
-    listOf(sounds.letters).forEach((row, i) => {
-        if (!isMap(row) || row.tongue === undefined || row.tongue === null) return;
-        const path = ["data", "sounds", "letters", i, "tongue"];
-        if (Array.isArray(row.tongue)) undeclared(row.tongue, (j) => [...path, j]);
-        else undeclared([row.tongue], () => path);
-    });
+    findings.push(...letterTongueFindings(sounds.letters, { declared, index, finding }));
     const edgeAt = new Map();
     listOf(sounds.edges).forEach((row, i) => {
         if (!isMap(row) || typeof row.edge !== "string") return;

package/engine/language-rows.mjs

@@ -253,7 +253,7 @@ export const LANGUAGE_COLUMN_TYPES = Object.freeze({
     joining: { position: "BIGINT", first: LIST, second: LIST },
     joins: { position: "BIGINT", letters: LIST },
     marks: { position: "BIGINT", letters: LIST },
-    skeleton: { position: "BIGINT", second: LIST },
+    skeleton: { position: "BIGINT", second: LIST, third: LIST },
     frames: {
         position: "BIGINT",
         class: LIST,
@@ -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,24 +897,28 @@ 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,
+    });
 }
 
 /**
- * The `skeleton` rows: one per `data.sounds.skeleton` entry, `second` a list.
+ * The `skeleton` rows: one per `data.sounds.skeleton` entry, `second` and `third` lists.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}
  */
 export function skeletonRows(records) {
     return listRows(records, (data) => soundsOf(data).skeleton, SKELETON_KEYS, {
-        lists: ["second"],
+        lists: ["second", "third"],
     });
 }
 

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
@@ -152,7 +152,7 @@ export const JOIN_MEETINGS = Object.freeze(["C+C", "V+C", "V+V"]);
 export const JOIN_RULES = Object.freeze(["merge", "insert", "drop", "double"]);
 
 /** What a written mark says of its letter. */
-export const MARK_KINDS = Object.freeze(["stress", "length"]);
+export const MARK_KINDS = Object.freeze(["stress", "length", "apart"]);
 
 /** How many of a mark a word may carry: `one` at most, or `any` number. */
 export const MARK_LIMITS = Object.freeze(["one", "any"]);
@@ -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",
@@ -817,6 +831,12 @@ export const SKELETON_FIELDS = Object.freeze([
         required: true,
         describe: "The second consonants of a root the row holds for; `any` for every other.",
     }),
+    Object.freeze({
+        name: "third",
+        ...SOUNDS_OR_ANY,
+        describe:
+            "The third consonants of a root the row holds for; every third consonant where absent.",
+    }),
     Object.freeze({
         name: "between",
         kind: "string",
@@ -914,10 +934,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 +970,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 +1067,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",