@heroiclands/package-build 24.0.1 → 24.0.3

package/engine/pdf-build.mjs

@@ -124,15 +124,7 @@ import {
     pdfTextWidth,
     resamplePdfImages,
 } from "./pdf-images.mjs";
-import {
-    ASSETS_SEGMENT,
-    assetPathnameKey,
-    pathnameProblem,
-    resolvePathname,
-} from "./pathnames.mjs";
-import { ASSET_SYSTEM, assetTypeOfRoot, isAssetShortcode } from "./asset-types.mjs";
-import { canonicalKey } from "./address.mjs";
-import { isComplete as isForeignCacheComplete, newestVersionDir } from "./metadata-index.mjs";
+import { assetPathnameKey, pathnameProblem, resolvePathname } from "./pathnames.mjs";
 import {
     createParser,
     labelFor,
@@ -147,7 +139,6 @@ import { noteInfoboxes } from "./infobox-registry.mjs";
 import { resolveIconGlyphs } from "./pdf-fonts.mjs";
 import { drawMapsFrom } from "./derived-sections.mjs";
 import { generatedDrawing } from "./generated-sections.mjs";
-import { resolveAssetReplacement } from "./asset-replacement.mjs";
 import { typstScriptFontPath } from "./script-font-delivery.mjs";
 
 /**
@@ -166,39 +157,18 @@ import { typstScriptFontPath } from "./script-font-delivery.mjs";
  * a build from touching a path outside its own output.
  *
  * A file **this** package ships stages directly. A pathname naming another
- * package's file stages instead from a declared replacement's cached archive,
- * when `opts.resolveReplacement` — the pure function
- * {@link module:engine/asset-replacement.resolveAssetReplacement} —
- * answers it; `opts.foreignIndex` is the merged index that answer is read
- * against. A pathname naming a package no replacement carries it for, or a
- * URL, names something no build here can open — a build reaches no network —
- * and the caller reports it as a picture the book will not carry.
+ * package's file, or a URL, names something no build here can open — a build
+ * reaches no network — and the caller reports it as a picture the book will
+ * not carry.
  *
  * @param {string} src - The pathname, as authored.
  * @param {object} config - The resolved configuration.
- * @param {object} [opts]
- * @param {Map<string, object>} [opts.foreignIndex] - Every fetched
- *   dependency's own records, keyed by canonical address — the index a
- *   replacement's record is read out of.
- * @param {Function} [opts.resolveReplacement] - {@link
- *   module:engine/asset-replacement.resolveAssetReplacement}, or an
- *   equivalent a caller injects for a test. Omitted, a foreign pathname this
- *   package does not own stays declined exactly as it always has.
  * @returns {{from: string, to: string}|null} The file, and where under the
  *   output directory it is staged.
- * @throws {Error} When a declared replacement answers the address but its
- *   archive was never fetched.
  */
-export function stagedImagePath(src, config, opts = {}) {
+export function stagedImagePath(src, config) {
     const forms = resolvePathname(src, config);
     if (!forms || forms.state !== "package") return null;
-    // A declared replacement answers before the package's own file does, which
-    // is the whole of what declaring one buys: the address a note writes is
-    // this package's own, and the picture staged for it is the replacement's.
-    // A miss falls through, so a package declaring none stages exactly what it
-    // ships.
-    const replaced = opts.resolveReplacement ? stagedReplacementPath(forms, config, opts) : null;
-    if (replaced) return replaced;
     if (forms.own) {
         return {
             from: path.resolve(config.rootDir, forms.local),
@@ -208,126 +178,6 @@ export function stagedImagePath(src, config, opts = {}) {
     return null;
 }
 
-/**
- * Every declared relationship that opted a dependency in as this package's
- * asset replacement, in declaration order.
- *
- * The same shape {@link module:engine/foreign-catalog.itemCatalogRelationships}
- * returns, read directly rather than through that module: this file stays a
- * leaf over the configuration it is handed, and the flag is as small to read
- * back as it was to validate.
- *
- * @param {object} config - The resolved build configuration.
- * @returns {Array<{id: string, package: string}>} The relationships, each
- *   with the package segment its own content index publishes under.
- */
-function assetReplacementRelationships(config) {
-    const out = [];
-    for (const entries of Object.values(config.relationships ?? {})) {
-        for (const rel of entries ?? []) {
-            if (rel.assetReplacement) {
-                out.push({ id: rel.id, package: rel.contentPackage ?? rel.id });
-            }
-        }
-    }
-    return out;
-}
-
-/**
- * The address a pathname this package does not own is read back as, for
- * asking whether a declared replacement answers it instead of the package
- * the pathname names.
- *
- * {@link module:engine/asset-replacement.resolveAssetReplacement} only ever
- * matches an address whose package segment is the compiling package's own,
- * so the pathname's own package is set aside and its suffix — the one piece
- * every surface derives from, and the piece a replacement publishes under
- * its own package instead — is read back as this package's type and
- * shortcode.
- *
- * @param {import("./pathnames.mjs").PathnameForms} forms - The pathname,
- *   resolved.
- * @param {object} config - The resolved build configuration.
- * @returns {string|null} The canonical address, or `null` when the suffix is
- *   not shaped like an asset's.
- */
-function localAssetAddress(forms, config) {
-    const segments = String(forms.suffix ?? "").split("/");
-    const assetType = assetTypeOfRoot(segments[0]);
-    if (!assetType) return null;
-    const base = segments[segments.length - 1];
-    const ext = path.extname(base);
-    const shortcode = (ext ? base.slice(0, -ext.length) : base).toLowerCase();
-    if (!isAssetShortcode(shortcode)) return null;
-    return canonicalKey(config.contentPackage, ASSET_SYSTEM, assetType.type, shortcode);
-}
-
-/**
- * The cache directory one relationship's archive was fetched into, found the
- * way {@link module:engine/foreign-catalog.foreignItemCatalogDirs} finds an
- * item catalogue's: the newest `.complete`-stamped `<id>@<version>`
- * directory under `config.paths.foreignCache`.
- *
- * @param {object} config - The resolved build configuration.
- * @param {string} id - The relationship's dependency id.
- * @returns {string|null} The directory, or `null` when nothing is cached.
- */
-function cachedReplacementDir(config, id) {
-    const root = config.paths.foreignCache;
-    if (!fs.existsSync(root)) return null;
-    const cached = fs
-        .readdirSync(root)
-        .filter((name) => name.startsWith(`${id}@`))
-        .map((name) => path.join(root, name))
-        .filter(isForeignCacheComplete);
-    return cached.length ? newestVersionDir(cached) : null;
-}
-
-/**
- * The file a declared replacement stages in place of a pathname this package
- * does not own, or `null` when no replacement answers it.
- *
- * @param {import("./pathnames.mjs").PathnameForms} forms - The pathname,
- *   resolved, with `forms.own` already `false`.
- * @param {object} config - The resolved build configuration.
- * @param {object} opts
- * @param {Map<string, object>} [opts.foreignIndex] - Every fetched
- *   dependency's own records, keyed by canonical address.
- * @param {Function} opts.resolveReplacement - {@link
- *   module:engine/asset-replacement.resolveAssetReplacement}.
- * @returns {{from: string, to: string}|null} The file, staged at the same
- *   `pdf`-relative path this address would have taken had this package
- *   shipped it.
- * @throws {Error} When the replacement that answers the address has not
- *   been fetched.
- */
-function stagedReplacementPath(forms, config, { foreignIndex = new Map(), resolveReplacement }) {
-    const address = localAssetAddress(forms, config);
-    if (!address) return null;
-    const relationships = assetReplacementRelationships(config);
-    if (!relationships.length) return null;
-    const hit = resolveReplacement(address, {
-        localPackage: config.contentPackage,
-        replacements: relationships.map((rel) => rel.package),
-        index: foreignIndex,
-    });
-    if (!hit) return null;
-    const assetPath = hit.record?.asset?.path;
-    if (!assetPath) return null;
-    const rel = relationships.find((entry) => entry.package === hit.package);
-    const dir = cachedReplacementDir(config, rel?.id ?? hit.package);
-    if (!dir) {
-        throw new Error(
-            `\`${hit.package}\` declares \`assetReplacement: true\` and carries \`${address}\`, ` +
-                "but its archive has not been fetched. Run `package-build deps fetch` first.",
-        );
-    }
-    return {
-        from: path.join(dir, ASSETS_SEGMENT, assetPath),
-        to: forms.pdf,
-    };
-}
-
 /**
  * Where the book keeps the pictures its section plates are drawn over.
  *
@@ -553,10 +403,6 @@ function configFileFor(config, rootDir) {
  *   {@link module:engine/pdf-pages}.
  * @param {Function} [opts.readPages] - {@link
  *   module:engine/pdf-pages.readEntryPages}, for tests.
- * @param {Function} [opts.resolveReplacement] - {@link
- *   module:engine/asset-replacement.resolveAssetReplacement}, for tests.
- *   Loaded from that module otherwise, and only when a relationship declares
- *   `assetReplacement: true` — a build with none never imports it.
  * @returns {Promise<{built: boolean, reason: string|null, findings: object[],
  *   imageReports: object[], books: Array<{id: string, title: string,
  *   built: boolean, typ: string, pdf: string|null, stats: object}>,
@@ -576,7 +422,6 @@ export async function buildPdf({
     version = "",
     compile = true,
     readPages = readEntryPages,
-    resolveReplacement,
 } = {}) {
     const resolved = config ?? loadPackConfig();
     const findings = [];
@@ -642,7 +487,7 @@ export async function buildPdf({
         out || resolved.pdf.out || path.join("build", "dist"),
     );
 
-    const world = await prepareWorld(resolved, { contentBase, findings, resolveReplacement });
+    const world = await prepareWorld(resolved, { contentBase, findings });
     if (!world) return none(null);
 
     const books = [];
@@ -944,11 +789,10 @@ function locateType(contentBase, record) {
  * @param {object} shared - Options.
  * @param {string} shared.contentBase - The content tree.
  * @param {object[]} shared.findings - Collected here rather than thrown.
- * @param {Function} [shared.resolveReplacement] - As {@link buildPdf}.
  * @returns {Promise<object|null>} The world, or null when a site gate fired
  *   and the findings say why.
  */
-async function prepareWorld(resolved, { contentBase, findings, resolveReplacement }) {
+async function prepareWorld(resolved, { contentBase, findings }) {
     // The corpus, once — the same records the index, the site and the SQL
     // tables read, so the book cannot select a note the other surfaces do not
     // have.
@@ -1038,17 +882,6 @@ async function prepareWorld(resolved, { contentBase, findings, resolveReplacemen
     const md = createParser(resolved.icons);
     const glyphs = resolveIconGlyphs(resolved.icons, resolved.pdf.iconFonts, findings);
 
-    // Asked only where a relationship declares `assetReplacement: true`: with
-    // none declared the resolver is never consulted, and staging gives the
-    // answer it gives a package that declares no replacement. A caller may
-    // supply its own, which is how the staging tests drive it.
-    const stagingOpts = {
-        foreignIndex: gates.foreign.index,
-        resolveReplacement:
-            resolveReplacement ??
-            (assetReplacementRelationships(resolved).length ? resolveAssetReplacement : null),
-    };
-
     return {
         records,
         db,
@@ -1060,7 +893,6 @@ async function prepareWorld(resolved, { contentBase, findings, resolveReplacemen
         assets,
         md,
         glyphs,
-        stagingOpts,
     };
 }
 
@@ -1150,7 +982,6 @@ async function selectBook(book, index, { world, configFile, configText, findings
  * @param {{get: Function}} [shared.elsewhere] - From
  *   {@link module:engine/pdf-pages.elsewhereFor}: the notes another book is
  *   home to, which this book names by book and page rather than links.
- * @param {Function} [shared.resolveReplacement] - As {@link buildPdf}.
  * @param {object[]} shared.findings - Collected here rather than thrown.
  * @returns {Promise<{built: boolean, typ: string|null, pdf: string|null,
  *   stats: object|null, imageReports?: object[]}>} What was written: the
@@ -1178,10 +1009,10 @@ async function buildBook(book, shared) {
      * @returns {{from: string, to: string}|null} As {@link stagedImagePath}.
      */
     const stage = (src) => {
-        const staged = stagedImagePath(src, resolved, world.stagingOpts);
+        const staged = stagedImagePath(src, resolved);
         return staged && { ...staged, to: inBook(staged.to) };
     };
-    const { records, site, gates, byFile, sqlTables, assets, md, glyphs, stagingOpts } = world;
+    const { records, site, gates, byFile, sqlTables, assets, md, glyphs } = world;
 
     fs.mkdirSync(outDir, { recursive: true });
 

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";

package/engine/script-font-delivery.mjs

@@ -13,9 +13,9 @@
 
 /**
  * **Delivering the installed faces to each target.** A consumer that installs
- * `@heroiclands/fonts` and sets text in one of its faces with `font=` gets the
- * fonts on the site, in the Foundry module and in its books; without both,
- * nothing ships and nothing links to it.
+ * `@heroiclands/fonts` and sets text in one of its faces, with `font=` or by a
+ * language note's `data.writtenIn`, gets the fonts on the site, in the Foundry
+ * module and in its books; without both, nothing ships and nothing links to it.
  *
  * - **Site and Foundry** receive `fonts.css`, listing only the WOFF2 sources,
  *   the WOFF2 files and `LICENSE`.
@@ -27,9 +27,12 @@
 import fs from "node:fs";
 import path from "node:path";
 
+import YAML from "yaml";
+
 import { baseStyleLayer } from "./base-styles.mjs";
 import { scanRuns } from "./content-scripts.mjs";
 import { FONTS_MANIFEST, resolveScriptFonts } from "./script-fonts.mjs";
+import { LANGUAGE_SUBTYPE } from "./word-terms.mjs";
 
 /**
  * Where the files land in the staged Foundry module, relative to its root.
@@ -65,10 +68,37 @@ const LICENSE = "LICENSE";
 /** The faces each configuration's notes set text in, found once. */
 const usedFaces = new WeakMap();
 
+/** A note's frontmatter block. */
+const FRONTMATTER = /^\uFEFF?---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
+
+/**
+ * The face a language note names in `data.writtenIn`, where it is installed.
+ *
+ * @param {string} source - The note's file.
+ * @param {import("./script-fonts.mjs").ScriptFonts} installed - The fonts package.
+ * @returns {string|undefined} The face's slug.
+ */
+function writtenInFace(source, installed) {
+    const yaml = FRONTMATTER.exec(source)?.[1];
+    if (yaml === undefined) return undefined;
+    let fm;
+    try {
+        fm = YAML.parse(yaml);
+    } catch {
+        return undefined;
+    }
+    if (fm?.type !== "skill" || String(fm.subType ?? "").toLowerCase() !== LANGUAGE_SUBTYPE)
+        return undefined;
+    const font = fm.data?.writtenIn?.font;
+    return typeof font === "string" && installed.faces.has(font) ? font : undefined;
+}
+
 /**
- * The faces the package's notes set text in with `font=`, read from the
- * notes themselves: every Markdown file under the content tree that writes
- * `font=` is scanned for its runs.
+ * The faces the package's notes set text in, read from the notes
+ * themselves: every Markdown file under the content tree that writes `font=`
+ * is scanned for its runs, and the face every language note names in
+ * `data.writtenIn` counts, since a run marked with the language alone is set
+ * in it.
  *
  * @param {DeliveryConfig} config - The resolved configuration.
  * @param {import("./script-fonts.mjs").ScriptFonts} installed - The fonts package.
@@ -90,10 +120,13 @@ export function facesUsed(config, installed) {
             if (entry.isDirectory()) walk(full);
             else if (entry.isFile() && entry.name.endsWith(".md")) {
                 const source = fs.readFileSync(full, "utf8");
+                if (/^\s*writtenIn:/m.test(source)) {
+                    const face = writtenInFace(source, installed);
+                    if (face) used.add(face);
+                }
                 if (!/\bfont=/.test(source)) continue;
-                const body = source.replace(
-                    /^\uFEFF?---\r?\n[\s\S]*?\r?\n---(?:\r?\n|$)/,
-                    (frontmatter) => frontmatter.replace(/[^\r\n]/g, " "),
+                const body = source.replace(FRONTMATTER, (frontmatter) =>
+                    frontmatter.replace(/[^\r\n]/g, " "),
                 );
                 const ctx = { languages: config.languages ?? {}, faces: installed.faces };
                 for (const run of scanRuns(body, ctx).runs)