@heroiclands/package-build 23.12.6 → 23.12.8

package/engine/verb-pattern.mjs

@@ -0,0 +1,99 @@
+/*
+ * 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
+ */
+
+/**
+ * **A language's one regular verb pattern, read once for every reader.** A
+ * language's `data.grammar.verbs` is `{ invariant: true }` or six `persons`
+ * endings, optionally with `replaces`. A present form is the citation form
+ * with the ending added; where the pattern states `replaces`, a citation form
+ * closing on those letters has them swapped for the ending, and one closing
+ * otherwise takes the ending whole, as a suffix's `replaces` does.
+ *
+ * The dictionary's verb table and a mapped run's lexicon check both read the
+ * pattern through {@link verbPattern} and build forms with {@link verbForm}.
+ *
+ * @module
+ */
+
+import { VERB_PERSON_FIELDS } from "./language-terms.mjs";
+
+/** Whether a value is a plain map. */
+const isMap = (value) => value !== null && typeof value === "object" && !Array.isArray(value);
+
+/**
+ * A stated verb pattern, as its readers use it.
+ *
+ * @typedef {object} VerbPattern
+ * @property {boolean} invariant - Whether verbs keep the citation form for
+ *   every person.
+ * @property {string|undefined} replaces - The letters each ending takes the
+ *   place of, where the pattern states them.
+ * @property {Array<{name: string, label: string, ending: string}>} endings -
+ *   The six endings in presentation order; empty for an invariant pattern.
+ */
+
+/**
+ * Read a language's verb pattern.
+ *
+ * @param {unknown} verbs - The language's `data.grammar.verbs`, as authored or
+ *   as a SQL row carries it (absent fields `null`).
+ * @returns {VerbPattern|undefined} The pattern, or `undefined` where none is
+ *   stated in full.
+ */
+export function verbPattern(verbs) {
+    if (!isMap(verbs)) return undefined;
+    const replaces =
+        typeof verbs.replaces === "string" && verbs.replaces.trim() ? verbs.replaces : undefined;
+    if (verbs.invariant === true) return { invariant: true, replaces, endings: [] };
+    const persons = isMap(verbs.persons) ? verbs.persons : undefined;
+    if (!persons || !VERB_PERSON_FIELDS.every(({ name }) => typeof persons[name] === "string"))
+        return undefined;
+    return {
+        invariant: false,
+        replaces,
+        endings: VERB_PERSON_FIELDS.map(({ name, label }) => ({
+            name,
+            label,
+            ending: persons[name],
+        })),
+    };
+}
+
+/**
+ * A stem with its closing letters swapped for an ending, or with the ending
+ * added where the stem does not close on them.
+ *
+ * @param {string} stem - The stem.
+ * @param {string} ending - The ending.
+ * @param {string|undefined} letters - The closing letters the ending takes
+ *   the place of; none adds the ending.
+ * @returns {string} The form.
+ */
+export function replaceClosing(stem, ending, letters) {
+    return letters && stem.endsWith(letters) ?
+            stem.slice(0, -letters.length) + ending
+        :   stem + ending;
+}
+
+/**
+ * The present form of a verb for one ending.
+ *
+ * @param {string} citation - The citation form.
+ * @param {string} ending - The person's ending; empty leaves the citation
+ *   form, less any closing `replaces`.
+ * @param {string} [replaces] - The pattern's `replaces`.
+ * @returns {string} The form.
+ */
+export function verbForm(citation, ending, replaces) {
+    return replaceClosing(citation, ending, replaces);
+}

package/engine/word-pattern.mjs

@@ -0,0 +1,27 @@
+/*
+ * 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
+ */
+
+/**
+ * **What a word is in running text.** A word is a maximal run of letters,
+ * combining marks and digits, and an apostrophe (`'` or `’`), a hyphen or an
+ * en dash joins two such runs into one word: `k'aralzon`, `Arzen-Thalor`.
+ * Anything else, whitespace and punctuation included, sits between words.
+ *
+ * The name catalog reads a label's last word by it, and a mapped run reads
+ * each word it looks up in a lexicon by it.
+ *
+ * @module
+ */
+
+/** One word; global, so `matchAll` walks every word of a text. */
+export const WORD = /[\p{L}\p{M}\p{N}]+(?:[’'–-][\p{L}\p{M}\p{N}]+)*/gu;

package/engine/word-rows.mjs

@@ -47,6 +47,12 @@ import {
     glossText,
 } from "./word-terms.mjs";
 
+/**
+ * The word's own keys a word row carries: all but `native`, whose entries are
+ * rows of the `natives` relation.
+ */
+const WORD_ROW_KEYS = Object.freeze(WORD_KEYS.filter((key) => key !== "native"));
+
 /** The columns a word row carries before the word's own keys. */
 const WORD_IDENTITY_COLUMNS = Object.freeze(["language", "position"]);
 
@@ -56,7 +62,7 @@ const WORD_DERIVED_COLUMNS = Object.freeze(["built_text", "built_parts", "senses
 /** Every column of the `words` relation, in order. */
 export const WORD_COLUMNS = Object.freeze([
     ...WORD_IDENTITY_COLUMNS,
-    ...WORD_KEYS,
+    ...WORD_ROW_KEYS,
     ...WORD_DERIVED_COLUMNS,
 ]);
 
@@ -260,7 +266,7 @@ export function wordRows(records, all = records) {
         words.forEach((entry, position) => {
             if (!isMap(entry)) return;
             const row = { language, position };
-            for (const key of WORD_KEYS) row[key] = entry[key] ?? null;
+            for (const key of WORD_ROW_KEYS) row[key] = entry[key] ?? null;
             if (row.name_sort === null) row.name_sort = row.form;
             const built = Array.isArray(entry.built) ? entry.built.map(String) : [];
             row.built_text = built.length ? built.join(" + ") : null;

package/engine/word-terms.mjs

@@ -99,6 +99,37 @@ export const WORD_SOURCE_FIELDS = Object.freeze([
     }),
 ]);
 
+/**
+ * The keys of one entry of a word's `native`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const WORD_NATIVE_FIELDS = Object.freeze([
+    Object.freeze({
+        name: "map",
+        kind: "string",
+        required: true,
+        shape: "a mapping note's `data.map.name`",
+        describe: "The map the native form is written for.",
+    }),
+    Object.freeze({
+        name: "font",
+        kind: "string",
+        shape: "a face the map lists",
+        describe:
+            "The one face the native form is for; unstated, it is for every face the map lists, " +
+            "and a form stated for a face wins over it there.",
+    }),
+    Object.freeze({
+        name: "text",
+        kind: "string",
+        required: true,
+        shape: "the word in the script, as the map's characters",
+        describe:
+            "The word as the script writes it, where the map's rows would write it otherwise.",
+    }),
+]);
+
 /**
  * The keys one word of a language note's `data.words` carries.
  *
@@ -209,6 +240,19 @@ export const WORD_FIELDS = Object.freeze([
         shape: "a frame of the language's `sounds.frames`",
         describe: "The frame a root is set in, named in the language's `sounds.frames`.",
     }),
+    Object.freeze({
+        name: "native",
+        kind: "list",
+        shape: "a list of `{ map, font?, text }`",
+        entries: Object.freeze({
+            kind: "map",
+            shape: "a map — `{ map, font?, text }`",
+            fields: WORD_NATIVE_FIELDS,
+        }),
+        describe:
+            "The word's native form under a map, stated only where the map's rows spell it " +
+            "differently. Its derived forms are spelled by the rows.",
+    }),
 ]);
 
 /** The keys of {@link WORD_FIELDS}, in declared order. */

package/hugo-theme/layouts/_default/baseof.html

@@ -9,6 +9,9 @@
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
   <link href="https://fonts.googleapis.com/css2?family=Cinzel:wght@400;500;600;700&family=JetBrains+Mono:wght@400;500&family=Lora:ital,wght@0,400;0,500;0,600;0,700;1,400;1,500;1,600&display=swap" rel="stylesheet">
   <link rel="stylesheet" href="{{ "css/style.css" | relURL }}">
+  {{/* Script fonts: the site build sets params.scriptFonts only when it has
+       copied them. */}}
+  {{ with .Site.Params.scriptFonts }}<link rel="stylesheet" href="{{ . | relURL }}">{{ end }}
   {{/* Icon glyphs. SoHL documentation writes icons as <i class="fa-solid …">
        or <i class="ginf-…">, the same markup the Foundry client renders, so a
        page reads identically in a journal and here. Font Awesome's FREE set is

package/hugo-theme/static/css/style.css

@@ -3022,3 +3022,13 @@ summary.info-sidebar-title::after {
 .single-body .dictionary > div > dd > :is(p, ul, ol, dl, blockquote, pre, table, div) { text-indent:0; }
 .single-body .dictionary > div > dd > p:first-child { display:inline; }
 @media (max-width:600px) { .single-body .dictionary { --indent:100px; } }
+
+/* ---- Text in one of the faces ----
+   The font family and features come from the face's own class. A
+   right-to-left block or verse reads from the right. `font=serif`, `sans`
+   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"], .poetry[dir="rtl"] { text-align:start; }
+.font-serif { font-family:var(--font-body); }
+.font-sans { font-family:sans-serif; }
+.font-mono { font-family:var(--font-mono); }

package/manifest.mjs

@@ -54,6 +54,7 @@ import fsSync from "node:fs";
 import path from "node:path";
 
 import { withBaseStyle } from "./engine/base-styles.mjs";
+import { scriptFontFiles, withScriptFontStyle } from "./engine/script-font-delivery.mjs";
 import { emitDiagnostic, formatDiagnostic, positionOfYamlPath } from "./engine/diagnostics.mjs";
 import { metadataFileName } from "./engine/metadata-index.mjs";
 
@@ -571,11 +572,18 @@ export function buildManifest({ config, packageJson, artifact, flags }) {
     // the five that do have no stylesheet of their own to name it from. See
     // `engine/base-styles.mjs` for the layer it loads into and why that is what
     // lets a package override it.
-    const styles = withBaseStyle({
+    const withBase = withBaseStyle({
         declared: declared.styles,
         artifact: /** @type {"system"|"module"} */ (artifact),
         enabled: config.packageBuild?.baseStyles !== false,
     });
+    // The installed script fonts' stylesheet follows it, when the module
+    // carries them: see `engine/script-font-delivery.mjs`.
+    const styles = withScriptFontStyle({
+        styles: withBase,
+        artifact: /** @type {"system"|"module"} */ (artifact),
+        delivered: scriptFontFiles(config, ["woff2"]) !== undefined,
+    });
     if (styles !== undefined) merged.styles = styles;
 
     // The index every consumer resolves this package's addresses through.

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "23.12.6",
+    "version": "23.12.8",
     "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",
@@ -160,7 +160,7 @@
         "markdown-it": "^15.0.0",
         "markdown-it-deflist": "^4.0.0",
         "markdown-it-footnote": "^4.0.0",
-        "markdownlint": "^0.41.1",
+        "markdownlint": "^0.42.0",
         "minimatch": "^10.2.6",
         "pagefind": "^1.5.2",
         "prettier": "^3.9.6",

package/types/content-config.d.mts

@@ -703,6 +703,12 @@ export type ContentBuildConfigInput = {
      * vocabulary is their union.
      */
     itemBuilders?: Record<string, ItemBuilderEntry> | readonly ItemRegistrySpec[] | undefined;
+    /**
+     * The languages a
+     * note may tag text with, by short
+     * name. Default `{}`.
+     */
+    languages?: Record<string, LanguageSpec> | undefined;
     /**
      * Packs to compile. More than one entry
      * may share a `type`: a note then names
@@ -891,6 +897,10 @@ export type ContentBuildConfig = {
      * none.
      */
     icons: import("./engine/content-icons.mjs").IconRegistry;
+    /**
+     *                                     Frozen; `{}` when absent.
+     */
+    languages: Readonly<Record<string, Readonly<LanguageSpec>>>;
     packs: readonly Readonly<ResolvedPackSpec>[];
     /**
      * Derived: every pack directory
@@ -918,3 +928,19 @@ export type ContentBuildConfig = {
     relationships: Readonly<Relationships>;
     publish: Readonly<PublishSwitches>;
 };
+/**
+ * One entry of `languages`.
+ */
+export type LanguageSpec = {
+    /**
+     * Its BCP 47 tag. A constructed language takes
+     * `art-x-<name>`.
+     */
+    tag: string;
+    /**
+     * The Address of its language note, whose
+     * `data.words` is the lexicon a mapped run in the
+     * language reads first.
+     */
+    note?: string | undefined;
+};

package/types/e2e.d.mts

@@ -419,7 +419,7 @@ export function suiteCommand(config: object, mode: "run" | "open"): string[];
 export function e2eRun({ config, packageJson, mode, suiteArgs, env, log, }: {
     config: object;
     packageJson: object;
-    mode?: "open" | "run" | undefined;
+    mode?: "run" | "open" | undefined;
     suiteArgs?: string[] | undefined;
     env?: NodeJS.ProcessEnv | undefined;
     log?: ((message: string) => void) | undefined;
@@ -494,7 +494,7 @@ export const E2E_SCENE_ID: "heroiclandsScene";
 /** How the suite may be run. */
 export const E2E_MODES: readonly string[];
 /** The Chrome for Testing build shared by local and CI Cypress runs. */
-export const CHROME_BUILD_ID: "155.0.8059.84";
+export const CHROME_BUILD_ID: "158.0.8110.0";
 /**
  * The disposable world's identity and credentials.
  */

package/types/engine/address-fields.d.mts

@@ -69,7 +69,7 @@ export type AddressPosition = {
      * - Where the Addresses are.
      * Defaults to `value`.
      */
-    holds?: "keys" | "value" | "items" | undefined;
+    holds?: "keys" | "items" | "value" | undefined;
     /**
      * - Resolve each exact target to its published Item UUID.
      */

package/types/engine/address-values.d.mts

@@ -75,7 +75,7 @@ export class AddressLink {
     constructor(target: object, anchor: string, kind?: "prose" | "event" | null);
     target: object;
     anchor: string;
-    kind: "event" | "prose" | null;
+    kind: "prose" | "event" | null;
 }
 /** The keys of an Address as the published index writes it, and no others. */
 export const PUBLISHED_ADDRESS_KEYS: readonly string[];

package/types/engine/asset-shipping.d.mts

@@ -110,6 +110,11 @@ export function assetsManifest(staged: readonly object[], stageDir: string): Ass
  * stage before a file is copied: a package whose provenance cannot be read is
  * not one whose shipping can be decided.
  *
+ * The pictures are written beside whatever a `packageBuild.assets` row already
+ * put under `icons/` and `images/`; nothing there is removed. A picture whose
+ * deployed path is already a file in the stage is a finding, and no picture is
+ * written. Clearing an earlier run's pictures is the stage reset's work.
+ *
  * @param {object} opts - Options.
  * @param {string} opts.assetsBase - The package's asset directory, the roots'
  *   parent.

package/types/engine/compile-corpus.d.mts

@@ -16,7 +16,7 @@
  *   the index refuses is a note the compile must still *report*, exactly as the
  *   compile loop reported it when the loop was the first to see it.
  * @param {import("./content-session.mjs").ContentSession} [opts.session] - Captured context shared with other operations.
- * @returns {Promise<{currentDate: string, records: object[], parsed: Map<string, object>, linkIndex: object, sqlTables: Map<string, object[]>|undefined, problems: object[], syntax?: import("./content-session.mjs").ContentSyntax}>} The corpus,
+ * @returns {Promise<{currentDate: string, runs: import("./content-scripts.mjs").RunContext, records: object[], parsed: Map<string, object>, linkIndex: object, sqlTables: Map<string, object[]>|undefined, problems: object[], syntax?: import("./content-session.mjs").ContentSyntax}>} The corpus,
  *   its indexes, and the notes it could not record.
  */
 export function buildCompileCorpus({ contentBase, assetsBase, skipDirectories, router, config, problems, session, }: {
@@ -29,6 +29,7 @@ export function buildCompileCorpus({ contentBase, assetsBase, skipDirectories, r
     session?: import("./content-session.mjs").ContentSession | undefined;
 }): Promise<{
     currentDate: string;
+    runs: import("./content-scripts.mjs").RunContext;
     records: object[];
     parsed: Map<string, object>;
     linkIndex: object;

package/types/engine/content-format-check.d.mts

@@ -117,7 +117,7 @@ export function checkDeclaredFields({ format, itemFields, system, severity }: {
     format: import("./content-format.mjs").ContentFormat;
     itemFields: Record<string, readonly object[]>;
     system: string;
-    severity?: "error" | "warning" | undefined;
+    severity?: "warning" | "error" | undefined;
 }): {
     findings: object[];
     coverage: object[];

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

@@ -81,6 +81,8 @@ export function asciiAliases(aliases: unknown): Array<string>;
  *   `name` reads `Map 1` rather than `Figure 1` where it is due — see
  *   {@link module:engine/content-figures.scanFigures}.
  * @param {import("./content-session.mjs").ContentSyntax} [options.syntax] - Session scanner projections.
+ * @param {import("./content-scripts.mjs").RunContext} [options.runContext] -
+ *   The configured languages, which give each run's `lang=` its tag.
  * @returns {Record<string, any>} The record, keys sorted at every depth. A
  *   **stub** — a note with an empty body, on a type an empty body suppresses —
  *   carries `address` and `anchors` as `null`: it publishes no page, so it
@@ -92,7 +94,7 @@ export function asciiAliases(aliases: unknown): Array<string>;
  *   otherwise be overwritten without a word. `file` and, where the file was
  *   read, `position` ride on the error.
  */
-export function buildIndexRecord({ frontmatter, relPath, absPath, raw, contentPackage, body, bodyLine, bodyColumn, nameTypes, manifest, addressContext, dateContext, resolveRole, syntax, }: {
+export function buildIndexRecord({ frontmatter, relPath, absPath, raw, contentPackage, body, bodyLine, bodyColumn, nameTypes, manifest, addressContext, dateContext, resolveRole, syntax, runContext, }: {
     frontmatter: Record<string, any>;
     relPath: string;
     absPath?: string | undefined;
@@ -107,12 +109,13 @@ export function buildIndexRecord({ frontmatter, relPath, absPath, raw, contentPa
     dateContext?: object | undefined;
     resolveRole?: ((address: string) => string | undefined) | undefined;
     syntax?: import("./content-session.mjs").ContentSyntax | undefined;
+    runContext?: import("./content-scripts.mjs").RunContext | undefined;
 }): Record<string, any>;
 /**
  * Derive every index record belonging to one parsed note.
  * @param {Parameters<typeof buildIndexRecord>[0]} options - Authored note and its context.
  */
-export function indexRecordsForNote({ frontmatter, body, bodyLine, bodyColumn, nameTypes, relPath, absPath, raw, contentPackage, manifest, addressContext, dateContext, resolveRole, syntax, }: Parameters<typeof buildIndexRecord>[0]): object[];
+export function indexRecordsForNote({ frontmatter, body, bodyLine, bodyColumn, nameTypes, relPath, absPath, raw, contentPackage, manifest, addressContext, dateContext, resolveRole, syntax, runContext, }: Parameters<typeof buildIndexRecord>[0]): object[];
 /**
  * Write each note's resolved culture into its record, as `data.culture`.
  *
@@ -209,6 +212,8 @@ export function resolveCultures(records: Array<Record<string, any>>, { contentPa
  *   calendar note's shortcode; see {@link module:engine/note-calendars}.
  * @param {string} [options.configFile] - The configuration file, where an
  *   unknown `defaultCalendar` is reported.
+ * @param {Readonly<Record<string, {tag: string}>>} [options.languages] - The
+ *   configured languages, which give each run's `lang=` its tag.
  * @param {(key: string) => ({culture?: unknown}|undefined)} [options.foreignRecord] -
  *   Another package's entry for a canonical address, read for a parent that
  *   package publishes; see {@link resolveCultures}.
@@ -221,7 +226,7 @@ export function resolveCultures(records: Array<Record<string, any>>, { contentPa
  * @returns {Array<Record<string, any>>} The records, in a total order that does
  *   not depend on directory-read order.
  */
-export function collectContentIndex(contentBase: string, { contentPackage, currentDate, defaultCalendar, configFile, skipDirectories, assetsBase, manifest, problems, addressContext, foreignRecord, parsed, sources, syntax, nameTypes, }: {
+export function collectContentIndex(contentBase: string, { contentPackage, currentDate, defaultCalendar, configFile, languages, skipDirectories, assetsBase, manifest, problems, addressContext, foreignRecord, parsed, sources, syntax, nameTypes, }: {
     contentPackage: string;
     skipDirectories: readonly string[];
     assetsBase?: string | undefined;
@@ -231,6 +236,9 @@ export function collectContentIndex(contentBase: string, { contentPackage, curre
     currentDate?: string | undefined;
     defaultCalendar?: string | undefined;
     configFile?: string | undefined;
+    languages?: Readonly<Record<string, {
+        tag: string;
+    }>> | undefined;
     foreignRecord?: ((key: string) => ({
         culture?: unknown;
     } | undefined)) | undefined;

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

@@ -49,3 +49,10 @@ export function renderPoetry(source: string): {
         message: string;
     }[];
 };
+/**
+ * The keys a poetry fence's attribute block takes. `lang`, `font` and `map`
+ * are read by `scanRuns` in content-scripts.mjs; `dir`, and on the site
+ * `data-pagefind-ignore`, are written by its rewrite of a fence set in one of
+ * the faces, and reach the element as they are written.
+ */
+export const POETRY_KEYS: readonly string[];