@heroiclands/package-build 24.0.1 → 24.0.3

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/site-reach.mjs

@@ -211,3 +211,26 @@ export function pruneGenerated(html, outside) {
     });
     return kept.join("");
 }
+
+/**
+ * Entries' links set as plain text where they lead outside a set of pages.
+ * Each link is the only child of a span carrying the class.
+ *
+ * @param {string} html - A page body.
+ * @param {(href: string) => boolean} outside - Whether an `href` names a page
+ *   of the site that is not to be linked.
+ * @param {string} className - The class the entries' links carry.
+ * @returns {string} The body with each such `<a>` replaced by its content.
+ */
+export function unlinkEntries(html, outside, className) {
+    const marked = new RegExp(
+        `<span\\b[^>]*?\\sclass=(?:"[^"]*\\b${className}\\b[^"]*"|'[^']*\\b${className}\\b[^']*')[^>]*>(<a\\b[^>]*>[\\s\\S]*?</a>)</span>`,
+        "gi",
+    );
+    return String(html ?? "").replace(marked, (span, anchor) => {
+        const match = new RegExp(ANCHOR.source, "i").exec(anchor);
+        const href = match ? (match[1] ?? match[2] ?? match[3] ?? "").replace(/&amp;/g, "&") : "";
+        if (href === "" || !outside(href)) return span;
+        return anchor.replace(/^<a\b[^>]*>/, "").replace(/<\/a>$/, "");
+    });
+}

package/engine/site-render.mjs

@@ -69,6 +69,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { LEXICAL_LINK_CLASS } from "./dictionary-layout.mjs";
 import { createRenderer } from "./content-render.mjs";
 import { resolvePathname } from "./pathnames.mjs";
 import { minifyHtml } from "./html-minify.mjs";
@@ -82,7 +83,13 @@ import {
 import { buildSite, gatesFailed } from "./site-build.mjs";
 import { readCachedNavigation, siteSettings } from "./site-config.mjs";
 import { atomFeed, robotsTxt, sitemapIndexXml, sitemapXml } from "./site-files.mjs";
-import { pageAddress, pruneGenerated, reachablePages, splitContent } from "./site-reach.mjs";
+import {
+    pageAddress,
+    pruneGenerated,
+    reachablePages,
+    splitContent,
+    unlinkEntries,
+} from "./site-reach.mjs";
 import { prepareTreeSqlTables } from "./sql-tables.mjs";
 import { placeGeography, searchMetadata } from "./site-search.mjs";
 import {
@@ -369,7 +376,12 @@ export function writeSite({ site, pages, out, report, staticDir = SITE_STATIC_DI
             },
             report: sink,
         });
-    const authoredOf = (page) => splitContent(page.content).authored;
+    const authoredOf = (page) =>
+        unlinkEntries(
+            splitContent(page.content).authored,
+            (url) => pageOfUrl(url) !== undefined,
+            LEXICAL_LINK_CLASS,
+        );
     const first = makeTheme({
         visible: (url) => pageOfUrl(url) === undefined,
         contentOf: authoredOf,
@@ -405,7 +417,10 @@ export function writeSite({ site, pages, out, report, staticDir = SITE_STATIC_DI
     const contentOf = (page) => {
         if (page.content === undefined) return page.content;
         const { authored, generated } = splitContent(page.content);
-        return authored + pruneGenerated(generated, outside);
+        return (
+            unlinkEntries(authored, outside, LEXICAL_LINK_CLASS) +
+            pruneGenerated(generated, outside)
+        );
     };
     const theme = makeTheme({ visible: (url) => !outside(url), contentOf, report });
 

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.3",
     "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",
@@ -184,6 +184,7 @@
     },
     "devDependencies": {
         "@changesets/cli": "^3.0.0",
+        "@heroiclands/fonts": "^0.1.5",
         "@types/node": "^26.2.0",
         "esbuild": "^0.28.2",
         "markdownlint": "^0.42.0",

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/content-config.d.mts

@@ -313,8 +313,7 @@ export type PathsInput = {
     unpack?: string | undefined;
     /**
      * Where a dependency declaring
-     *      `itemCatalog: true` or
-     *      `assetArchive: true` is unpacked.
+     *      `itemCatalog: true` is unpacked.
      *      Inbound, and fetched rather than
      *      committed.
      */
@@ -486,13 +485,6 @@ export type RelationshipSpec = {
      *  does not hold. Needs a `manifest`.
      */
     itemCatalog?: boolean | undefined;
-    /**
-     * Whether `deps fetch` unpacks this
-     * dependency's release archive for its
-     * asset bytes alone, building no item
-     * catalogue from it. Needs a `manifest`.
-     */
-    assetArchive?: boolean | undefined;
     /**
      * Whether `deps fetch` fetches this
      * dependency's content index. Default
@@ -504,16 +496,6 @@ export type RelationshipSpec = {
      * index.
      */
     contentIndex?: boolean | undefined;
-    /**
-     * Whether this dependency's asset
-     * tree answers this package's own asset
-     * addresses ahead of its local record.
-     * Default `false`. Refuses `contentIndex:
-     * false` on the same entry, since a
-     * replacement with no fetched index to
-     * check against resolves nothing.
-     */
-    assetReplacement?: boolean | undefined;
 };
 /**
  * How a generated documentation page is framed in the repository publishing it.

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/dictionary-layout.d.mts

@@ -60,6 +60,11 @@ export const LAYOUT_REQUIRED_COLUMNS: Readonly<{
 export const COMMON_MARK: "\u2022";
 /** The word-entry span class whose Foundry rendering is a native TOC heading. */
 export const DICTIONARY_ENTRY_CLASS: "dictionary-entry";
+/**
+ * The class on every link an entry writes to another note, so a site can set
+ * the link as plain text where its target is not a page a reader can reach.
+ */
+export const LEXICAL_LINK_CLASS: "lexical-ref";
 export type LayoutOptions = {
     /**
      * - Whether an Address can be