@heroiclands/package-build 23.2.1 → 23.3.0

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

@@ -15,7 +15,7 @@
        enough — the system deliberately uses no Pro-only icons — and the
        game-icons webfont is subset to just the glyphs the docs reference
        (~3 KB), generated by the SoHL repo. */}}
-  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/7.0.1/css/all.min.css" crossorigin="anonymous" referrerpolicy="no-referrer">
+  <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/font-awesome/7.3.1/css/all.min.css" crossorigin="anonymous" referrerpolicy="no-referrer">
   <link rel="stylesheet" href="{{ "css/sohl-icons.css" | relURL }}">
 </head>
 <body>

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "23.2.1",
+    "version": "23.3.0",
     "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/types/e2e.d.mts

@@ -208,15 +208,19 @@ export function deployForContainer({ config, env, log, runScript, }: {
  * @param {string} opts.url - The container's base URL.
  * @param {string} opts.container - The container name, for its log.
  * @param {string} opts.stage - The stage, named in a licence failure.
+ * @param {string} [opts.dataRoot] - The stage's data root, named when its licence is unsigned.
+ * @param {(container: string) => string} [opts.readLog] - Reads the container's log since it started.
  * @param {number} [opts.timeoutMs] - How long to wait.
  * @param {(message: string) => void} [opts.log] - Progress reporting.
  * @returns {Promise<void>} Resolves once the world is active.
  * @throws {Error} On a licence failure or a timeout.
  */
-export function waitForWorld({ url, container, stage, timeoutMs, log }: {
+export function waitForWorld({ url, container, stage, dataRoot, readLog, timeoutMs, log, }: {
     url: string;
     container: string;
     stage: string;
+    dataRoot?: string | undefined;
+    readLog?: ((container: string) => string) | undefined;
     timeoutMs?: number | undefined;
     log?: ((message: string) => void) | undefined;
 }): Promise<void>;

package/types/engine/index.d.mts

@@ -22,6 +22,7 @@ export * as placeRelations from "./place-relations.mjs";
 export * as holdings from "./holdings.mjs";
 export * as populations from "./populations.mjs";
 export * as marketClass from "./market-class.mjs";
+export * as settlementTables from "./settlement-tables.mjs";
 export * as mapPlaces from "./map-places.mjs";
 export * as mapLayout from "./map-layout.mjs";
 export * as mapDot from "./map-dot.mjs";

package/types/engine/infobox.d.mts

@@ -50,7 +50,7 @@ export function hasValue(value: unknown): boolean;
  */
 export function humanizeFieldName(name: string): string;
 /**
- * An enumerated value as a reader sees it: `graying_brown` → `graying brown`.
+ * An enumerated value as a reader sees it: `greying_brown` → `greying brown`.
  *
  * @param {unknown} value - The authored value.
  * @returns {string} The text.

package/types/engine/note-vocabulary.d.mts

@@ -130,6 +130,19 @@ export function dataFields(type: string, vocabulary?: Readonly<Record<string, Ty
  *   it has no `subType` at all — see {@link TypeVocabulary}.
  */
 export function subTypes(type: string, vocabulary?: Readonly<Record<string, TypeVocabulary>>): readonly string[] | null | undefined;
+/**
+ * The words a being's look is stated in, keyed by the `data:` field that takes
+ * them.
+ *
+ * Each field is closed to its list: any other value, an empty one included, is
+ * a finding at the value naming the words it takes. `appearance.complexion`
+ * takes one word or a list of them, and each entry is checked on its own.
+ * `appearance.extra_features` is not here: it is free text, a list of the marks
+ * no word covers.
+ *
+ * @type {Readonly<Record<string, readonly LookWord[]>>}
+ */
+export const BEING_LOOK_VOCABULARY: Readonly<Record<string, readonly LookWord[]>>;
 /**
  * What happened to or at a subject — the `events` key, declared once and spread
  * into every type that carries events, so the schema cannot differ between
@@ -333,6 +346,24 @@ export const BEING_ARCHETYPES: Readonly<{
  * @type {Readonly<Record<string, TypeVocabulary>>}
  */
 export const NOTE_VOCABULARY: Readonly<Record<string, TypeVocabulary>>;
+/**
+ * One word of a closed vocabulary: the value a note writes, the label a reader
+ * sees it by, and what it means.
+ */
+export type LookWord = {
+    /**
+     * - The word as a note writes it.
+     */
+    value: string;
+    /**
+     * - The word as a reader sees it.
+     */
+    label: string;
+    /**
+     * - What it means, in one line.
+     */
+    describe: string;
+};
 /**
  * One `data:` key a note type may carry.
  *

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

@@ -17,6 +17,9 @@ export function indexMarker(slug: string, main?: boolean): string;
  * @param {object} [opts] - Options.
  * @param {(entry: object) => boolean} [opts.owns] - Whether this book is the
  *   entry's home. Every entry when absent.
+ * @param {string[]} [opts.heads] - Leading words (`pdf.indexHeads`) matched
+ *   literally against the start of a name; a name that opens with one is also
+ *   listed as `<rest>, <head>`, the head without its trailing space or colon. None when absent.
  * @param {Array<{slug: string, name: string, title: string, page: string|number}>} [opts.foreign] -
  *   Notes another book prints, listed as `Name: Book title, p. N` once this
  *   book mentions them.
@@ -24,8 +27,9 @@ export function indexMarker(slug: string, main?: boolean): string;
  *   foreign?: {title: string, page: string}}>} Terms with `see` set for a
  *   cross-reference to the main name it points at.
  */
-export function indexTerms(entries: object[], { owns, foreign }?: {
+export function indexTerms(entries: object[], { owns, foreign, heads }?: {
     owns?: ((entry: object) => boolean) | undefined;
+    heads?: string[] | undefined;
     foreign?: {
         slug: string;
         name: string;

package/types/engine/pdf-pages.d.mts

@@ -10,6 +10,26 @@
  * @returns {string[]} The arguments, in order.
  */
 export function evalArgs(typPath: string, fontArgs: string[]): string[];
+/**
+ * Say why a finished Typst process failed.
+ *
+ * A process killed by a signal has no exit status and prints nothing, so the
+ * signal is named; `SIGKILL` is the kernel's out-of-memory kill. Otherwise the
+ * first line the compiler printed is the reason, and the exit code stands in
+ * when it printed none.
+ *
+ * @param {{status: number | null, signal: string | null, stderr?: string | null, stdout?: string | null}} result -
+ *   The finished process.
+ * @param {string} binary - The Typst binary.
+ * @param {string} subcommand - The Typst subcommand that ran.
+ * @returns {string} The reason, ready to follow the failing command's name.
+ */
+export function typstFailure(result: {
+    status: number | null;
+    signal: string | null;
+    stderr?: string | null;
+    stdout?: string | null;
+}, binary: string, subcommand: string): string;
 /**
  * Measure the page each labelled entry of a book starts on.
  *

package/types/engine/settlement-tables.d.mts

@@ -0,0 +1,164 @@
+/**
+ * Every settlements table in a note, read from the raw file so each line
+ * number is the file's own.
+ *
+ * @param {string} raw - The whole note, frontmatter included.
+ * @returns {{heading: number, tables: SettlementTable[]}} The `## Settlements`
+ *   heading's line, 0 when there is none, and its tables.
+ */
+export function findSettlementTables(raw: string): {
+    heading: number;
+    tables: SettlementTable[];
+};
+/**
+ * Check a place note's settlements tables.
+ *
+ * Declared as part of the `place` vocabulary's whole-note check, so the lint
+ * runs it with the index every reference resolves through. Without an index
+ * nothing is reported.
+ *
+ * @param {object} note - The note, as the link index hands it over.
+ * @param {object} [opts]
+ * @param {object} [opts.index] - The link index, holding the whole corpus.
+ * @returns {object[]} Findings.
+ */
+export function checkSettlementTables(note: object, { index }?: {
+    index?: object | undefined;
+}): object[];
+/** The heading text a settlements table stands under, at level two. */
+export const SETTLEMENTS_HEADING: "Settlements";
+/**
+ * How a region's countryside is held, each the tag a region carries to say so.
+ *
+ * `holder` is what the `Held by` cell names under that model. `person` says
+ * whether that holder may be a person: only where land is held by a person or
+ * a house may the cell link a `being`.
+ *
+ * **The tags stay open.** They are not a declared tag group: a group would
+ * report every tag within a typo's distance of one — a region tagged `hellad`
+ * reads as a near miss of `held` — and a misspelled model on a note with a
+ * table is already reported, because the note then names no model at all.
+ *
+ * @type {ReadonlyArray<Readonly<{tag: string, holder: string, person: boolean}>>}
+ */
+export const HOLDING_MODELS: ReadonlyArray<Readonly<{
+    tag: string;
+    holder: string;
+    person: boolean;
+}>>;
+/**
+ * The table's columns, in the order the header states them. An optional
+ * column may be left out; the header carries no other column, and keeps this
+ * order.
+ *
+ * @type {ReadonlyArray<Readonly<{name: string, required: boolean}>>}
+ */
+export const SETTLEMENT_COLUMNS: ReadonlyArray<Readonly<{
+    name: string;
+    required: boolean;
+}>>;
+/**
+ * The rules this module enforces, each `name` the prefix its findings carry.
+ *
+ * @type {ReadonlyArray<Readonly<{name: string, describe: string}>>}
+ */
+export const SETTLEMENT_TABLE_RULES: ReadonlyArray<Readonly<{
+    name: string;
+    describe: string;
+}>>;
+/**
+ * One cell, as authored.
+ */
+export type Cell = {
+    /**
+     * - The cell, trimmed.
+     */
+    text: string;
+    /**
+     * - The 1-based column its text starts at.
+     */
+    column: number;
+};
+/**
+ * One settlements table.
+ */
+export type SettlementTable = {
+    /**
+     * - The 1-based line of its header.
+     */
+    line: number;
+    /**
+     * - The header cells.
+     */
+    header: string[];
+    /**
+     * - Whether the header is the declared columns.
+     */
+    wellFormed: boolean;
+    /**
+     * - Each
+     * row's cells keyed by column name; empty when the header is not well formed.
+     */
+    rows: Array<{
+        line: number;
+        cells: Record<string, Cell>;
+    }>;
+    /**
+     * - The 1-based line of its last row.
+     */
+    last: number;
+    /**
+     * - Whether prose follows it before the next heading.
+     */
+    tailed: boolean;
+};
+/**
+ * One place note, as the rules read it.
+ */
+export type PlaceNode = {
+    /**
+     * - The note.
+     */
+    note: object;
+    /**
+     * - Lower case.
+     */
+    shortcode: string;
+    subType: string;
+    title: string;
+    /**
+     * - Its name and aliases, lower case.
+     */
+    names: Set<string>;
+    /**
+     * - Enclosing places' shortcodes.
+     */
+    parents: string[];
+    section: {
+        heading: number;
+        tables: SettlementTable[];
+    };
+};
+/**
+ * Everything the rules ask of the whole tree.
+ */
+export type Corpus = {
+    /**
+     * - By shortcode.
+     */
+    places: Map<string, PlaceNode>;
+    /**
+     * - By note.
+     */
+    byNote: Map<object, PlaceNode>;
+    /**
+     * - Region shortcode → the
+     * settlement notes its table covers.
+     */
+    covers: Map<string, PlaceNode[]>;
+    /**
+     * - Settlement note → the region
+     * notes whose tables link it, in path order.
+     */
+    rowedIn: Map<object, object[]>;
+};