@heroiclands/package-build 24.0.1 → 24.0.2

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)

package/engine/script-fonts.mjs

@@ -68,6 +68,9 @@ export const FONTS_MANIFEST = "fonts.json";
  * @property {string} direction - `ltr` or `rtl`.
  * @property {string[]} features - OpenType features it turns on.
  * @property {ReadonlySet<number>} draws - Every code point it draws.
+ * @property {string|undefined} file - The absolute path of its TrueType file,
+ *   which the book draws a `scroll` fence's outlines from; `undefined` when the
+ *   manifest lists none.
  */
 
 /**
@@ -164,6 +167,10 @@ export function resolveScriptFonts(rootDir) {
                 direction: entry.direction === "rtl" ? "rtl" : "ltr",
                 features: Object.freeze([...(entry.features ?? [])]),
                 draws,
+                file:
+                    typeof entry.files?.ttf === "string" ?
+                        path.join(root, entry.files.ttf)
+                    :   undefined,
             }),
         );
     }

package/engine/verse-metre.mjs

@@ -129,6 +129,7 @@ export function stressIndex(word, rule, pairs) {
     const count = nuclei.length;
     if (count <= 1) return 0;
     if (count === 2) return rule.two === "last" ? 1 : 0;
+    if (rule.longer === "first") return 0;
     if (rule.longer === "antepenultimate") return count - 3;
     if (rule.longer === "final") return count - 1;
     return count - 2;

package/engine/written-in.mjs

@@ -0,0 +1,208 @@
+/*
+ * 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 script a language is written in.** A language note — a `skill` of
+ * `subType: language` — names the map and the face its text is written in:
+ *
+ * ```yaml
+ * data:
+ *   writtenIn: { map: semaron, font: semaron-kuriale }
+ * ```
+ *
+ * A run marked with the language's name takes them where it states neither:
+ * `[Zaron tholmeza]{lang=vyl}` is mapped by `semaron` and set in
+ * `semaron-kuriale`. A run that states one of the two takes the other from the
+ * default only where they agree, so the run is never set in a face its map is
+ * not drawn in:
+ *
+ * - **`map=` alone** takes the default `font` where that map is drawn in it.
+ * - **`font=` alone** takes the default `map` where the map is drawn in that
+ *   face.
+ * - **Both** take nothing.
+ *
+ * The default belongs to the run's own language, after a div or fence around
+ * it has given it its keys: a span marked `lang=en` inside a div of a language
+ * with a default takes no face from it.
+ *
+ * @module
+ */
+
+import { positionOfFrontmatterPath } from "./diagnostics.mjs";
+import { nearest } from "./near-miss.mjs";
+import { compileMap } from "./text-maps.mjs";
+import { LANGUAGE_SUBTYPE } from "./word-terms.mjs";
+
+/** The `data` key a language note names its script in. */
+export const WRITTEN_IN_KEY = "writtenIn";
+
+/**
+ * A language's script.
+ *
+ * @typedef {object} WrittenIn
+ * @property {string} map - The `data.map.name` of the mapping note.
+ * @property {string} font - The slug of the face, one the map is drawn in.
+ */
+
+/** Whether a value is a plain map. */
+const isMap = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+
+/**
+ * Whether a map is drawn in a face: it lists the face, or lists none.
+ *
+ * @param {import("./text-maps.mjs").TextMap} map - The map.
+ * @param {string} font - The face's slug.
+ * @returns {boolean} Whether the map may set text in it.
+ */
+export function drawnIn(map, font) {
+    return !map.fonts.size || map.fonts.has(font);
+}
+
+/** A list of names as prose: `a`, `a` and `b`, `a`, `b` and `c`. */
+function said(names) {
+    const quoted = names.map((name) => `\`${name}\``);
+    return quoted.length < 2 ?
+            quoted.join("")
+        :   `${quoted.slice(0, -1).join(", ")} and ${quoted.at(-1)}`;
+}
+
+/**
+ * The script each configured language's note names, where the map is known
+ * and is drawn in the face. A default that names an unknown map or a face its
+ * map is not drawn in is the note's finding, and fills no run.
+ *
+ * @param {ReadonlyMap<string, Record<string, any>>} byName - Each configured
+ *   language's note record, by language name, from
+ *   {@link module:engine/map-lexicon.languageRecordsByName}.
+ * @param {ReadonlyMap<string, import("./text-maps.mjs").TextMap>} maps - The
+ *   maps by name.
+ * @returns {Map<string, WrittenIn>} The scripts, by language name.
+ */
+export function writtenInOf(byName, maps) {
+    const out = new Map();
+    for (const [name, record] of byName ?? []) {
+        const value = record?.data?.[WRITTEN_IN_KEY];
+        if (!isMap(value) || typeof value.map !== "string" || typeof value.font !== "string")
+            continue;
+        const map = maps?.get(value.map);
+        if (!map || !drawnIn(map, value.font)) continue;
+        out.set(name, Object.freeze({ map: value.map, font: value.font }));
+    }
+    return out;
+}
+
+/**
+ * The keys a run takes from its language's script: each of `map` and `font`
+ * the run does not state, where it agrees with the one the run does.
+ *
+ * @param {{lang?: string, map?: string, font?: string}} keys - The run's keys,
+ *   its own and those it inherits.
+ * @param {ReadonlyMap<string, WrittenIn>|undefined} scripts - Each language's
+ *   script, from {@link writtenInOf}.
+ * @param {ReadonlyMap<string, import("./text-maps.mjs").TextMap>|undefined} maps -
+ *   The maps by name.
+ * @returns {{map?: string, font?: string}} What the run takes; empty when it
+ *   takes nothing.
+ */
+export function fromWrittenIn(keys, scripts, maps) {
+    if (keys.lang === undefined || (keys.map !== undefined && keys.font !== undefined)) return {};
+    const script = scripts?.get(keys.lang);
+    if (!script) return {};
+    if (keys.map === undefined && keys.font === undefined) return { ...script };
+    if (keys.map === undefined) {
+        const map = maps?.get(script.map);
+        return map && drawnIn(map, /** @type {string} */ (keys.font)) ? { map: script.map } : {};
+    }
+    const map = maps?.get(keys.map);
+    return map && drawnIn(map, script.font) ? { font: script.font } : {};
+}
+
+/** The maps each lint index's notes declare, read once. */
+const declaredMaps = new WeakMap();
+
+/**
+ * Each map the index's notes declare, by name; the first note to declare a
+ * name keeps it.
+ *
+ * @param {{notes?: Iterable<{fm?: Record<string, any>}>}} index - The lint index.
+ * @returns {Map<string, import("./text-maps.mjs").TextMap>} The maps.
+ */
+function mapsIn(index) {
+    const known = declaredMaps.get(index);
+    if (known) return known;
+    const maps = new Map();
+    for (const note of index.notes ?? []) {
+        const map = compileMap(note?.fm?.data?.map);
+        if (map && !maps.has(map.name)) maps.set(map.name, map);
+    }
+    declaredMaps.set(index, maps);
+    return maps;
+}
+
+/**
+ * Check a note's `data.writtenIn`: that the note is a language, that `map`
+ * names a map a mapping note declares, and that the map is drawn in `font`.
+ * The data-key check owns the keys and their kinds.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
+ * @param {{index?: {notes?: Iterable<object>}}} [context] - The lint index;
+ *   without one, only the note's `subType` is checked.
+ * @returns {object[]} The findings, each at its key or value.
+ */
+export function checkWrittenIn(note, { index } = {}) {
+    const value = note?.fm?.data?.[WRITTEN_IN_KEY];
+    if (value === undefined || value === null) return [];
+    const raw = note.raw ?? "";
+    /**
+     * @param {Array<string|number>} keyPath - Where the fault is.
+     * @param {string} message - What is wrong.
+     * @param {boolean} [key] - Locate the key rather than its value.
+     */
+    const finding = (keyPath, message, key = false) => ({
+        file: note.file,
+        ...positionOfFrontmatterPath(raw, ["data", WRITTEN_IN_KEY, ...keyPath], { key }),
+        severity: "error",
+        message,
+    });
+    if (String(note.fm?.subType ?? "").toLowerCase() !== LANGUAGE_SUBTYPE)
+        return [
+            finding(
+                [],
+                `\`data.${WRITTEN_IN_KEY}\` names the script a language is written in, and this ` +
+                    `note's \`subType\` is not \`${LANGUAGE_SUBTYPE}\``,
+                true,
+            ),
+        ];
+    if (!index || !isMap(value) || typeof value.map !== "string") return [];
+    const maps = mapsIn(index);
+    const map = maps.get(value.map);
+    if (!map) {
+        const near = nearest(value.map, [...maps.keys()]);
+        return [
+            finding(
+                ["map"],
+                `\`data.${WRITTEN_IN_KEY}.map\` is \`${value.map}\`, which no mapping note's ` +
+                    "`data.map.name` declares" +
+                    (near ? `; did you mean \`${near}\`?` : ""),
+            ),
+        ];
+    }
+    if (typeof value.font !== "string" || drawnIn(map, value.font)) return [];
+    return [
+        finding(
+            ["font"],
+            `\`data.${WRITTEN_IN_KEY}.font\` is \`${value.font}\`, which the map \`${map.name}\` ` +
+                `is not drawn in; it is drawn in ${said([...map.fonts.keys()])}`,
+        ),
+    ];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "24.0.1",
+    "version": "24.0.2",
     "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/site-theme/static/css/style.css

@@ -3114,6 +3114,13 @@ summary.info-sidebar-title::after {
    and `mono` set the site's own serif and mono, and the reader's sans. */
 .script-block { margin:1rem 0; line-height:1.7; }
 .script-block[dir="rtl"], .verse[dir="rtl"] { text-align:start; }
+/* A scroll: columns top to bottom, read from the right; the line height is the
+   column pitch, one em and half an em between columns. A panel wider than the
+   page scrolls sideways from the right. */
+.single-content .scroll { writing-mode:vertical-rl; line-height:1.5; inline-size:max-content; max-block-size:100%; overflow-x:auto; overflow-y:hidden; margin:1rem 0; }
+.single-content .scroll[data-rows] { inline-size:calc(var(--scroll-rows) * 1em); }
+.single-content .scroll[data-cols] { block-size:calc(var(--scroll-cols) * 1.5em); }
+.single-content .scroll p { margin:0; text-indent:0; }
 .font-serif { font-family:var(--font-body); }
 .font-sans { font-family:sans-serif; }
 .font-mono { font-family:var(--font-mono); }

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

@@ -63,6 +63,10 @@ export function scanRuns(source: string, ctx?: RunContext, syntax?: import("./co
  * - **A div or fence in a right-to-left face** carries `dir=rtl`. No direction
  *   mark, `<bdo>` or `<bdi>` is ever written: the code points carry their own
  *   direction.
+ * - **A scroll fence's body** is rewritten to one line per paragraph, its
+ *   lines joined by what the map writes for a space, and left unescaped,
+ *   since the body is raw. Its layout, each character with the source text it
+ *   was written from, is returned for the book, which draws it.
  *
  * A run with a finding is left as written; {@link scanRuns} reports it.
  *
@@ -72,8 +76,9 @@ export function scanRuns(source: string, ctx?: RunContext, syntax?: import("./co
  *   scanner projections.
  * @param {{target?: "site"|"foundry"|"book"}} [options] - The target the
  *   Markdown is rendered for; only `site` writes the search marker.
- * @returns {{markdown: string, errors: Array<{line: number, column: number, message: string}>}}
- *   The rewritten Markdown, and the findings of {@link scanRuns}.
+ * @returns {{markdown: string, errors: Array<{line: number, column: number, message: string}>, scrolls: Map<string, import("./content-scroll.mjs").ScrollLayout>}}
+ *   The rewritten Markdown, the findings of {@link scanRuns}, and each
+ *   rewritten scroll fence's layout, by its rewritten body.
  */
 export function renderRuns(source: string, ctx?: RunContext, syntax?: import("./content-session.mjs").ContentSyntax, options?: {
     target?: "site" | "foundry" | "book";
@@ -84,6 +89,7 @@ export function renderRuns(source: string, ctx?: RunContext, syntax?: import("./
         column: number;
         message: string;
     }>;
+    scrolls: Map<string, import("./content-scroll.mjs").ScrollLayout>;
 };
 /** The keys this module reads, which no construct passes through as written. */
 export const RUN_KEYS: readonly string[];
@@ -184,6 +190,11 @@ export type RunDetail = {
      * - The emphasis it holds, by absolute offset.
      */
     emphasis: Delimiter[];
+    /**
+     * - A scroll fence whose opening has a finding,
+     * which is left as written.
+     */
+    unrolled?: boolean | undefined;
 };
 /**
  * What a run is checked against.
@@ -208,6 +219,12 @@ export type RunContext = {
      * {@link module :engine/text-maps.mapsFromRecords}.
      */
     maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap> | undefined;
+    /**
+     * -
+     * The script each configured language's note names, by language name, from
+     * {@link module :engine/written-in.writtenInOf}.
+     */
+    writtenIn?: ReadonlyMap<string, import("./written-in.mjs").WrittenIn> | undefined;
     /**
      * -
      * Each configured language's lexicon by name, from
@@ -243,17 +260,25 @@ export type RunContext = {
      * from {@link module :engine/script-emphasis.languageEmphasesOf}.
      */
     languageEmphases?: ReadonlyMap<string, import("./script-emphasis.mjs").LanguageEmphasis> | undefined;
+    /**
+     * - Each face whose
+     * script is written in columns, from the script notes, by
+     * {@link module :engine/script-direction.directionsFromRecords}.
+     */
+    directions?: ReadonlyMap<string, "vertical-rl"> | undefined;
 };
 /**
- * One span, div or verse fence carrying `lang=`, `font=` or `map=`. Its
- * `lang`, `font` and `map` are the ones it is set with: its own, else the
- * innermost div or fence around it that states one.
+ * One span, div, verse fence or scroll fence carrying `lang=`, `font=` or
+ * `map=`. Its `lang`, `font` and `map` are the ones it is set with: its own,
+ * else the innermost div or fence around it that states one, else its
+ * language's script. A scroll fence that still names no face takes the face of
+ * its map where the map is drawn in one.
  */
 export type Run = {
     /**
      * - Which construct.
      */
-    kind: "span" | "block" | "verse";
+    kind: "span" | "block" | "verse" | "scroll";
     /**
      * - The language as written.
      */

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

@@ -0,0 +1,179 @@
+/**
+ * Read every `scroll` fence in a source, and every fault in its opening.
+ *
+ * A fence inside a block quote or an HTML block is not read, and neither is a
+ * fence quoted inside another fence.
+ *
+ * @param {string} source - Markdown.
+ * @returns {{blocks: Scroll[], errors: Array<{line: number, column: number, message: string}>}}
+ *   The fences, and each finding at its 1-based position.
+ */
+export function scanScrolls(source: string): {
+    blocks: Scroll[];
+    errors: Array<{
+        line: number;
+        column: number;
+        message: string;
+    }>;
+};
+/**
+ * A scroll's paragraphs: each run of nonblank lines, its lines trimmed and
+ * joined by a space.
+ *
+ * @param {string[]} lines - The body's lines.
+ * @returns {string[]} The paragraphs, in order.
+ */
+export function scrollParagraphs(lines: string[]): string[];
+/**
+ * Replace each well-formed `scroll` fence with the HTML block the site, the
+ * preview and Foundry show: a `<div class="scroll">` holding a `<p>` for each
+ * paragraph, its size carried as `--scroll-rows` and `--scroll-cols`. A fence
+ * with a finding in its opening is left as a code fence.
+ *
+ * @param {string} source - Markdown, its marked text already rewritten.
+ * @returns {{markdown: string}} The Markdown.
+ */
+export function renderScroll(source: string): {
+    markdown: string;
+};
+/**
+ * One character of a scroll as the book draws it.
+ *
+ * @typedef {object} ScrollCell
+ * @property {string} text - The character, one code point.
+ * @property {string} roman - The source text it was written from: the text of
+ *   the piece of the map it begins, with the text of any piece before it that
+ *   wrote nothing; `""` for a later character of the same piece.
+ * @property {"rubric"|"overline"} [emphasis] - The convention it is set by.
+ */
+/**
+ * A scroll's text, as the book lays it out.
+ *
+ * @typedef {object} ScrollLayout
+ * @property {ScrollCell[][]} paragraphs - Each paragraph's characters.
+ * @property {import("./script-fonts.mjs").Face|undefined} face - The face it
+ *   is drawn in.
+ */
+/**
+ * Lay a scroll's paragraphs into columns and the columns into panels.
+ *
+ * Each paragraph starts a fresh column, filled from the top, `rows` characters
+ * to a column; the columns are read from the right and grouped `cols` to a
+ * panel. Without `rows`, a column is as long as the longest paragraph, up to
+ * {@link BOOK_SCROLL_ROWS}; without `cols`, each column is a panel of its own,
+ * so the book sets as many beside one another as fit its measure.
+ *
+ * @param {ScrollCell[][]} paragraphs - The characters of each paragraph.
+ * @param {{rows?: number, cols?: number}} size - The fence's size.
+ * @returns {{rows: number, panels: ScrollCell[][][]}} The column length, and
+ *   each panel's columns, the first column the rightmost.
+ */
+export function scrollPanels(paragraphs: ScrollCell[][], { rows, cols }?: {
+    rows?: number;
+    cols?: number;
+}): {
+    rows: number;
+    panels: ScrollCell[][][];
+};
+/**
+ * The roman text a panel was written from, as its alt text: each paragraph's
+ * source text, a space between paragraphs, its spacing collapsed.
+ *
+ * @param {ScrollCell[][]} panel - The panel's columns.
+ * @param {ScrollCell[][]} paragraphs - The scroll's paragraphs, so a column
+ *   that begins a paragraph is told from one that continues it.
+ * @returns {string} The text.
+ */
+export function panelRoman(panel: ScrollCell[][], paragraphs: ScrollCell[][]): string;
+/**
+ * The keys a scroll fence's attribute block takes. `lang`, `font` and `map`
+ * are read by `scanRuns`; `data-pagefind-ignore` is written on the site by its
+ * rewrite of a fence set in a face, and reaches the element as written.
+ */
+export const SCROLL_KEYS: readonly string[];
+/**
+ * The distance from one column to the next, in ems: the character's one em
+ * and a gap of half an em.
+ */
+export const SCROLL_PITCH: 1.5;
+/**
+ * The longest column the book sets when a fence states no `rows=`: each
+ * paragraph is one column as long as the longest, up to this many characters.
+ */
+export const BOOK_SCROLL_ROWS: 40;
+/** The class every scroll carries. */
+export const SCROLL_CLASS: "scroll";
+/**
+ * One `scroll` fence.
+ */
+export type Scroll = {
+    /**
+     * - The 0-based line of its opening.
+     */
+    start: number;
+    /**
+     * - The 0-based line of its closing.
+     */
+    end: number;
+    /**
+     * - Its fence marker.
+     */
+    fence: string;
+    /**
+     * - The opening line's indentation.
+     */
+    indent: string;
+    /**
+     * - Its `key=value` attributes.
+     */
+    attributes: Record<string, string>;
+    /**
+     * - Its classes.
+     */
+    classes: string[];
+    /**
+     * - Its `rows=`, where it is valid.
+     */
+    rows: number | undefined;
+    /**
+     * - Its `cols=`, where it is valid.
+     */
+    cols: number | undefined;
+    /**
+     * - Whether its opening has a finding.
+     */
+    invalid: boolean;
+};
+/**
+ * One character of a scroll as the book draws it.
+ */
+export type ScrollCell = {
+    /**
+     * - The character, one code point.
+     */
+    text: string;
+    /**
+     * - The source text it was written from: the text of
+     * the piece of the map it begins, with the text of any piece before it that
+     * wrote nothing; `""` for a later character of the same piece.
+     */
+    roman: string;
+    /**
+     * - The convention it is set by.
+     */
+    emphasis?: "rubric" | "overline" | undefined;
+};
+/**
+ * A scroll's text, as the book lays it out.
+ */
+export type ScrollLayout = {
+    /**
+     * - Each paragraph's characters.
+     */
+    paragraphs: ScrollCell[][];
+    /**
+     * - The face it
+     * is drawn in.
+     */
+    face: import("./script-fonts.mjs").Face | undefined;
+};

package/types/engine/font-outlines.d.mts

@@ -0,0 +1,67 @@
+/**
+ * The outlines of a TrueType face, read once per file.
+ *
+ * @param {string} file - The `.ttf`.
+ * @returns {Outlines} Its outlines.
+ * @throws {Error} When the file is not a TrueType face with outlines.
+ */
+export function fontOutlines(file: string): Outlines;
+/**
+ * One panel of a scroll as SVG: its columns read from the right, `rows` ems
+ * tall, each character centred in its column, in red where it is set in the
+ * rubric and with a line beside it, on the right, where it is overlined.
+ *
+ * @param {import("./content-scroll.mjs").ScrollCell[][]} panel - Its columns,
+ *   the first the rightmost.
+ * @param {number} rows - The characters in a column.
+ * @param {Outlines} outlines - The face.
+ * @returns {string} The SVG.
+ */
+export function scrollPanelSvg(panel: import("./content-scroll.mjs").ScrollCell[][], rows: number, outlines: Outlines): string;
+/** The book's rubric red, which its preamble names `book-rubric`. */
+export const BOOK_RUBRIC: "#9c281b";
+/** The book's ink, which its preamble names `book-ink`. */
+export const BOOK_INK: "#241f1a";
+/**
+ * A point of a contour.
+ */
+export type Point = {
+    x: number;
+    y: number;
+    on: boolean;
+};
+/**
+ * One glyph, in font units, its y axis pointing down from the baseline.
+ */
+export type Glyph = {
+    /**
+     * - Its glyph index.
+     */
+    index: number;
+    /**
+     * - Its outline as SVG path data; `""` for none.
+     */
+    d: string;
+    /**
+     * - Its horizontal advance.
+     */
+    advance: number;
+    /**
+     * - From the top of its cell to its baseline.
+     */
+    top: number;
+};
+/**
+ * A face's outlines.
+ */
+export type Outlines = {
+    /**
+     * - Its units per em.
+     */
+    unitsPerEm: number;
+    /**
+     * - The glyph a code
+     * point is drawn with, or `undefined` when the face does not draw it.
+     */
+    glyph: (point: number) => Glyph | undefined;
+};