@heroiclands/package-build 24.0.0 → 24.0.2

package/engine/site-root.mjs

@@ -51,7 +51,8 @@
 import fs from "node:fs";
 import path from "node:path";
 import * as pagefind from "pagefind";
-import { gunzipSync } from "node:zlib";
+
+import { feedPaths, reachablePages } from "./site-reach.mjs";
 
 import { formatDiagnostic } from "./diagnostics.mjs";
 
@@ -149,11 +150,40 @@ export function headers({ pkg, base, fonts = false } = {}) {
  * binary.
  *
  * @callback SiteIndexer
- * @param {{site: string, output: string}} where - The rendered site, and the
- *   directory inside it the index is written to.
+ * @param {{site: string, output: string, base?: string}} where - The rendered
+ *   site, the directory inside it the index is written to, and the path the
+ *   site is served at. With a `base`, only the pages reachable from the
+ *   homepage are indexed.
  * @returns {Promise<{pages: number}>} How many pages were indexed.
  */
 
+/**
+ * The addresses of the pages reachable from a rendered site's homepage.
+ *
+ * @param {string} site - The rendered site's directory, served at `base`.
+ * @param {string} base - The path the site is served at.
+ * @returns {Set<string>} Page addresses, each beginning with `base`.
+ */
+function reachableFromDisk(site, base) {
+    const file = (url) => path.join(site, ...url.slice(base.length).split("/").filter(Boolean));
+    const read = (target) => {
+        try {
+            return fs.readFileSync(target, "utf8");
+        } catch {
+            return undefined;
+        }
+    };
+    return reachablePages({
+        base,
+        html: (url) => read(path.join(file(url), "index.html")),
+        expand: (target) => {
+            if (!target.endsWith(".xml")) return [];
+            const xml = read(file(target));
+            return xml === undefined ? [] : feedPaths(xml);
+        },
+    });
+}
+
 /**
  * Build the search index of a rendered site with Pagefind.
  *
@@ -169,12 +199,17 @@ export function headers({ pkg, base, fonts = false } = {}) {
  * - The binary missing is reported by the package as an install failure of
  *   its own; it is rethrown naming the platform package to install.
  *
+ * With a `base`, the index covers the pages reachable from the homepage by
+ * the links the rendered HTML carries, and no others: an unlinked page is
+ * served but not searchable. Each reachable page is handed to Pagefind as its
+ * own file, so a page outside the set is never read.
+ *
  * The output directory is emptied first, so an index of an earlier build's
  * pages never survives beside the current one.
  *
  * @type {SiteIndexer}
  */
-export async function indexSite({ site, output }) {
+export async function indexSite({ site, output, base }) {
     if (!fs.statSync(site, { throwIfNoEntry: false })?.isDirectory()) {
         throw new Error(`${site} is not a directory, so there is nothing to index`);
     }
@@ -201,33 +236,40 @@ export async function indexSite({ site, output }) {
     }
     let pages;
     try {
-        const added = await index.addDirectory({ path: site });
-        if (added.errors.length) throw new Error(added.errors.join("; "));
-        pages = added.page_count;
+        if (base) {
+            pages = 0;
+            for (const url of reachableFromDisk(site, base)) {
+                const sourcePath = path.posix.join(
+                    ...url.slice(base.length).split("/"),
+                    "index.html",
+                );
+                const content = fs.readFileSync(path.join(site, sourcePath), "utf8");
+                const added = await index.addHTMLFile({ sourcePath, content });
+                if (added.errors.length) throw new Error(added.errors.join("; "));
+                pages += 1;
+            }
+        } else {
+            const added = await index.addDirectory({ path: site });
+            if (added.errors.length) throw new Error(added.errors.join("; "));
+            pages = added.page_count;
+        }
         if (!pages) {
             throw new Error(`no page under ${site} was indexed — the site holds no HTML`);
         }
-        const written = await index.writeFiles({ outputPath: output });
-        if (written.errors.length) throw new Error(written.errors.join("; "));
+        // The files are taken from the index in memory and written here,
+        // because `writeFiles` can answer while the binary is still flushing
+        // them, which leaves an index that a reader loads half-written.
+        const { files, errors } = await index.getFiles();
+        if (errors.length) throw new Error(errors.join("; "));
+        if (!files.length) throw new Error("the search index holds no files");
+        for (const file of files) {
+            const target = path.join(output, file.path);
+            fs.mkdirSync(path.dirname(target), { recursive: true });
+            fs.writeFileSync(target, file.content);
+        }
     } finally {
         await pagefind.close();
     }
-    // Pagefind may finish its API call while fragment writes are still visible
-    // as incomplete gzip streams under heavy parallel load. A successful site
-    // build must hand deployment complete fragments.
-    const fragmentDir = path.join(output, "fragment");
-    const deadline = Date.now() + 5000;
-    for (;;) {
-        try {
-            const fragments = fs.readdirSync(fragmentDir);
-            if (!fragments.length) throw new Error("no search fragments were written");
-            for (const name of fragments) gunzipSync(fs.readFileSync(path.join(fragmentDir, name)));
-            break;
-        } catch (error) {
-            if (Date.now() >= deadline) throw error;
-            await new Promise((resolve) => setTimeout(resolve, 25));
-        }
-    }
     return { pages };
 }
 
@@ -289,7 +331,7 @@ export async function writeSiteRoot({ pkg, base, out, search = true, indexer = i
     }
     let pages;
     try {
-        ({ pages } = await indexer({ site: rendered, output: dir }));
+        ({ pages } = await indexer({ site: rendered, output: dir, base: prefix }));
     } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         // A directory, so the locator is the file field alone: there is no

package/engine/site-serve.mjs

@@ -45,6 +45,7 @@ import path from "node:path";
 import { siteBuildFailed } from "./site-build.mjs";
 import { SITE_THEME_DIR } from "./site-theme.mjs";
 import { SITE_STATIC_DIR, buildPackageSite, writeSite, writeThemeFiles } from "./site-render.mjs";
+import { siteBase } from "../content-config.mjs";
 import { SEARCH_DIR, indexSite } from "./site-root.mjs";
 
 /** The address a served page listens on for the server's reloads. */
@@ -165,7 +166,7 @@ export async function serveSite({
 
     const indexForSearch = async () => {
         if (!search || config.site.search === false || !state) return;
-        await indexSite({ site: out, output: path.join(out, SEARCH_DIR) });
+        await indexSite({ site: out, output: path.join(out, SEARCH_DIR), base: siteBase(config) });
     };
 
     await buildAll();

package/engine/site-theme.mjs

@@ -37,7 +37,9 @@
  * `draftNotice`, `scriptFonts`), its `menu`, and `pages`, every regular page
  * as `{url, title, section, type, subType, date, content}`. `tagPages` says the site
  * writes a page for each tag, and `pageExists` answers whether a path inside
- * the site is published. `feed` is the site's Atom feed as `{title, url,
+ * the site is published. `visible`, where the site sets it, answers whether a
+ * generated link may point at a URL; the Related card, the previous and next
+ * links and the infobox links leave out, or set as plain text, what it refuses. `feed` is the site's Atom feed as `{title, url,
  * section}`, `section` being the one its posts are listed in, and
  * `mergeIndexes` the search bundles of other sites its search reads beside
  * its own.
@@ -453,11 +455,14 @@ export function createSiteTheme({ site, dir = SITE_THEME_DIR, bannerData, report
         return { bannerUrl: url, title, tagline };
     };
 
-    /** One infobox entry. */
+    /** Whether a generated link may point at a URL: any, where the site sets no `visible`. */
+    const visible = (url) => (typeof site.visible === "function" ? site.visible(url) : true);
+
+    /** One infobox entry; one that leads outside the reachable pages is its text alone. */
     const entryOf = (entry) => ({
         lead: text(entry?.lead),
         text: text(entry?.text),
-        url: entry?.url ? safeUrl(entry.url) : "",
+        url: entry?.url && visible(entry.url) ? safeUrl(entry.url) : "",
     });
 
     /** The value of one row, by its kind. */
@@ -552,7 +557,7 @@ export function createSiteTheme({ site, dir = SITE_THEME_DIR, bannerData, report
         const deliberate = [];
         const merged = [];
         for (const ref of related.seeAlso ?? []) {
-            if (seen.has(ref.url)) continue;
+            if (seen.has(ref.url) || !visible(ref.url)) continue;
             seen.add(ref.url);
             deliberate.push({
                 url: safeUrl(ref.url),
@@ -561,7 +566,7 @@ export function createSiteTheme({ site, dir = SITE_THEME_DIR, bannerData, report
             });
         }
         for (const ref of [...(related.mentions ?? []), ...(related.backlinks ?? [])]) {
-            if (seen.has(ref.url)) continue;
+            if (seen.has(ref.url) || !visible(ref.url)) continue;
             seen.add(ref.url);
             merged.push(ref);
         }
@@ -595,7 +600,15 @@ export function createSiteTheme({ site, dir = SITE_THEME_DIR, bannerData, report
 
     /** The prev/next links of a page. */
     const navOf = (page, narrow) => {
-        const { prev, next } = neighbours(page, narrow);
+        const { prev, next } = neighbours(
+            {
+                ...page,
+                siblings: (page.siblings ?? []).filter(
+                    (item) => item.url === page.url || visible(item.url),
+                ),
+            },
+            narrow,
+        );
         if (!prev && !next) return undefined;
         const link = (item) => item && { url: safeUrl(item.url), title: text(item.title) };
         return { prev: link(prev), next: link(next) };

package/engine/sql-tables.mjs

@@ -603,11 +603,7 @@ async function createEventRelation(connection, file, records, prefix, audience)
     fs.writeFileSync(file, rows.map((row) => JSON.stringify(row)).join("\n"));
     // `whenIn` and `untilIn` are keyed by calendar Address, and read as structs
     // whatever their number of keys, so `whenIn['<calendar>']` always binds.
-    await createTableFromFile(
-        connection,
-        `${prefix}events`,
-        readJsonAuto(file).replace(/\)$/, ", map_inference_threshold=-1)"),
-    );
+    await createTableFromFile(connection, `${prefix}events`, readJsonAuto(file));
 }
 
 /**
@@ -941,13 +937,20 @@ async function createRowRelation(connection, file, rows, view, columns, types) {
  * type's fields with `NULL` where a record lacks one. A dependency's index has
  * exactly the same shape and needs exactly the same reading.
  *
+ * `map_inference_threshold=-1` keeps every object a struct. Left at its default,
+ * DuckDB reads an object whose keys are sparsely spread across rows (the mean
+ * share of rows carrying a key falls under `field_appearance_threshold`) as a
+ * map, so `data.<key>` changes meaning with the corpus: one more field on one
+ * note can turn a plain comparison into a JSON conversion error.
+ *
  * @param {string} file - The JSONL to read.
  * @returns {string} The `SELECT … FROM read_json_auto(…)` clause.
  */
 function readJsonAuto(file) {
     return (
         `SELECT * FROM read_json_auto('${file.replace(/'/g, "''")}', ` +
-        `format='newline_delimited', union_by_name=true, maximum_object_size=20000000)`
+        `format='newline_delimited', union_by_name=true, maximum_object_size=20000000, ` +
+        `map_inference_threshold=-1)`
     );
 }
 

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.0",
+    "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.
      */