@heroiclands/package-build 23.2.2 → 23.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "23.2.2",
+    "version": "23.3.1",
     "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/appearance-profile.d.mts

@@ -0,0 +1,94 @@
+/**
+ * The genders every profile states a height range for.
+ *
+ * A function as well as a constant: `note-vocabulary.mjs` reads it while the
+ * module graph is still evaluating, before any `const` here is initialised,
+ * and a function declaration is bound from the start.
+ *
+ * @returns {readonly string[]} The genders.
+ */
+export function requiredHeightGenders(): readonly string[];
+/**
+ * The profile keys that take weighted words, read from the vocabulary: every
+ * being-look field but `gender`, by its last segment.
+ *
+ * @param {Readonly<Record<string, readonly {value: string}[]>>} lookVocabulary
+ * @returns {string[]} The keys, in the vocabulary's order.
+ */
+export function profileLookKeys(lookVocabulary: Readonly<Record<string, readonly {
+    value: string;
+}[]>>): string[];
+/**
+ * Everything wrong with a profile.
+ *
+ * @param {unknown} profile - The profile as authored.
+ * @param {Readonly<Record<string, readonly {value: string}[]>>} lookVocabulary -
+ *   The being-look vocabulary.
+ * @returns {ProfileProblem[]} The problems, in the order a reader meets them.
+ */
+export function profileProblems(profile: unknown, lookVocabulary: Readonly<Record<string, readonly {
+    value: string;
+}[]>>): ProfileProblem[];
+/**
+ * The frontmatter lint's check of `data.appearanceProfile`.
+ *
+ * Scoped to a `lore` note of `subType: culture`: on any other lore it is an
+ * error at the key. On a culture it reports what the field's declared inner
+ * keys cannot: words outside the vocabulary, weights that are not positive, a
+ * word map with no words, height ranges that are unreadable, reversed or keyed
+ * by no gender, and a missing `female` or `male` range.
+ *
+ * @param {object} note - The note: `file`, `raw` and parsed `fm`.
+ * @param {Readonly<Record<string, readonly {value: string}[]>>} lookVocabulary -
+ *   The being-look vocabulary.
+ * @returns {object[]} Findings, located at the word, weight or key at fault.
+ */
+export function checkAppearanceProfile(note: object, lookVocabulary: Readonly<Record<string, readonly {
+    value: string;
+}[]>>): object[];
+/**
+ * A profile's problems as findings at the culture note that states it, for a
+ * caller holding the note but not running the lint.
+ *
+ * @param {object} note - The culture note: `file`, `raw` and parsed `fm`.
+ * @param {Readonly<Record<string, readonly {value: string}[]>>} lookVocabulary -
+ *   The being-look vocabulary.
+ * @returns {object[]} Every problem, shape included, as findings.
+ */
+export function profileFindings(note: object, lookVocabulary: Readonly<Record<string, readonly {
+    value: string;
+}[]>>): object[];
+/** The `lore` subType whose notes may carry a profile. */
+export const PROFILE_SUBTYPE: "culture";
+/** The genders every profile states a height range for. */
+export const REQUIRED_HEIGHT_GENDERS: readonly string[];
+/**
+ * The body-mass index band, in kg/m², each frame word means, lightest to
+ * heaviest. The bands meet end to end, so every weight at a given height falls
+ * in exactly one frame.
+ *
+ * @type {Readonly<Record<string, readonly [number, number]>>}
+ */
+export const FRAME_MASS_INDEX: Readonly<Record<string, readonly [number, number]>>;
+/**
+ * One thing wrong with a profile.
+ */
+export type ProfileProblem = {
+    /**
+     * - Where, from the profile itself.
+     */
+    path: Array<string | number>;
+    /**
+     * - The fault is the key at `path`, not its value.
+     */
+    key?: boolean | undefined;
+    /**
+     * - The frontmatter lint's inner-key walk reports
+     * this too, from the field's declaration.
+     */
+    shape?: boolean | undefined;
+    /**
+     * - What is wrong, naming the full `data.` path.
+     */
+    message: string;
+};

package/types/engine/data-keys.d.mts

@@ -5,7 +5,7 @@
  * @property {string} name - The key as an author writes it.
  * @property {string} [kind] - Its value's shape: `string`, `date`, `number`,
  *   `integer`, `boolean`, `address`, `list`, `map`, `scalar-or-map`,
- *   or `string-or-list` — see {@link fitsKind}. Absent, the check
+ *   `string-or-list`, or `string-list-or-map` — see {@link fitsKind}. Absent, the check
  *   makes no claim about the value.
  * @property {readonly string[]} [allowed] - The closed set a present value is
  *   one of, where the key takes a fixed word.
@@ -94,7 +94,7 @@ export type InnerKeySpec = {
     /**
      * - Its value's shape: `string`, `date`, `number`,
      * `integer`, `boolean`, `address`, `list`, `map`, `scalar-or-map`,
-     * or `string-or-list` — see {@link fitsKind}. Absent, the check
+     * `string-or-list`, or `string-list-or-map` — see {@link fitsKind}. Absent, the check
      * makes no claim about the value.
      */
     kind?: string | undefined;

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/language-names.d.mts

@@ -0,0 +1,140 @@
+/**
+ * The genders every `data.names.given` states a list for.
+ *
+ * A function rather than a `const`: `note-vocabulary.mjs` reads it while the
+ * module graph is still evaluating.
+ *
+ * @returns {readonly string[]} The genders.
+ */
+export function requiredGivenGenders(): readonly string[];
+/**
+ * A pattern read into literal text and placeholders.
+ *
+ * @param {string} pattern - The pattern as written.
+ * @returns {{parts: PatternPart[], problems: string[]}} The parts, and what is
+ *   wrong with the pattern's own spelling.
+ */
+export function parsePattern(pattern: string): {
+    parts: PatternPart[];
+    problems: string[];
+};
+/**
+ * The patterns a name of `gender` may take: every pattern where they are not
+ * keyed by gender, the gender's own where it has some, else every pattern
+ * stated.
+ *
+ * @param {object} names - Checked `data.names`.
+ * @param {string} gender - A gender word.
+ * @returns {string[]} The patterns.
+ */
+export function patternsFor(names: object, gender: string): string[];
+/**
+ * Everything wrong with a language's name lists.
+ *
+ * @param {unknown} names - `data.names` as authored.
+ * @param {Readonly<Record<string, readonly {value: string}[]>>} lookVocabulary -
+ *   The being-look vocabulary, whose `gender` words key `given`.
+ * @returns {NamesProblem[]} The problems, in the order a reader meets them.
+ */
+export function namesProblems(names: unknown, lookVocabulary: Readonly<Record<string, readonly {
+    value: string;
+}[]>>): NamesProblem[];
+/**
+ * The frontmatter lint's check of `data.names`.
+ *
+ * Scoped to a `skill` note of `subType: language`: on any other skill it is an
+ * error at the key. On a language it reports what the field's declared inner
+ * keys cannot: a pattern that does not parse, a placeholder naming no list, a
+ * list no pattern names, a list name a placeholder cannot spell, an empty list
+ * of patterns or of names, an empty name, a pattern or given list keyed by no
+ * gender, and a missing `female` or `male` list. Each is located at the pattern, list, entry or key at fault.
+ *
+ * @param {object} note - The note: `file`, `raw` and parsed `fm`.
+ * @param {Readonly<Record<string, readonly {value: string}[]>>} lookVocabulary -
+ *   The being-look vocabulary.
+ * @returns {object[]} Findings.
+ */
+export function checkLanguageNames(note: object, lookVocabulary: Readonly<Record<string, readonly {
+    value: string;
+}[]>>): object[];
+/**
+ * A language's name-list problems as findings at the note that states them,
+ * shape included, for a caller holding the note but not running the lint.
+ *
+ * @param {object} note - The language note: `file`, `raw` and parsed `fm`.
+ * @param {Readonly<Record<string, readonly {value: string}[]>>} lookVocabulary -
+ *   The being-look vocabulary.
+ * @returns {object[]} Every problem, as findings.
+ */
+export function namesFindings(note: object, lookVocabulary: Readonly<Record<string, readonly {
+    value: string;
+}[]>>): object[];
+/**
+ * The given names a gender draws from: its own list, or every given list
+ * together where it has none.
+ *
+ * @param {object} names - Checked `data.names`.
+ * @param {string} gender - A gender word.
+ * @returns {string[]} The names.
+ */
+export function givenNames(names: object, gender: string): string[];
+/**
+ * A name drawn from a language's lists: one of the gender's patterns, where it
+ * has more than one, then each placeholder an even draw from its list.
+ *
+ * @param {object} names - Checked `data.names`.
+ * @param {string} gender - A gender word.
+ * @param {() => number} next - A stream of numbers in `[0, 1)`.
+ * @returns {string} The name.
+ */
+export function drawName(names: object, gender: string, next: () => number): string;
+/**
+ * Why a name does not fit a language's lists, or `undefined` where it fits.
+ *
+ * A name fits when it takes one of the patterns for `gender`, with every
+ * placeholder filled by a name of its list: `{given}` from the gender's given
+ * list, `{given.<gender>}` from that gender's. Names compare in Unicode NFC, so
+ * a precomposed and a decomposed accent are one letter.
+ *
+ * @param {string} full - The name as given.
+ * @param {object} names - Checked `data.names`.
+ * @param {string} gender - A gender word.
+ * @returns {string|undefined} One sentence naming the part that does not fit.
+ */
+export function nameMisfit(full: string, names: object, gender: string): string | undefined;
+/** The `skill` subType whose notes may carry name lists. */
+export const NAMES_SUBTYPE: "language";
+/** The placeholder that draws from the given-name list for a gender. */
+export const GIVEN_LIST: "given";
+/**
+ * One piece of a parsed pattern: literal text, or a placeholder naming a list
+ * and, for `given`, the gender whose list it draws from.
+ */
+export type PatternPart = {
+    literal: string;
+} | {
+    list: string;
+    gender?: string;
+};
+/**
+ * One thing wrong with a language's name lists.
+ */
+export type NamesProblem = {
+    /**
+     * - Where, from `data.names` itself.
+     */
+    path: Array<string | number>;
+    /**
+     * - The fault is the key at `path`, not its value.
+     */
+    key?: boolean | undefined;
+    /**
+     * - The frontmatter lint's inner-key walk reports
+     * this too, from the field's declaration.
+     */
+    shape?: boolean | undefined;
+    /**
+     * - What is wrong, naming the full `data.` path.
+     */
+    message: string;
+};

package/types/engine/literature-notes.d.mts

@@ -13,16 +13,27 @@ export function checkLanguageChoice(note: object, { index }?: {
     index?: object;
 }): object[];
 /**
- * Refuse a literature field on a lore note of any other subType.
+ * Refuse a literature field on a lore note of any other subType, and
+ * `data.language` on a lore note that is neither a work nor a culture.
  *
  * @param {object} note
- * @returns {object[]} One error per literature key written off `literature`.
+ * @returns {object[]} One error per key written off the subTypes that take it.
  */
 export function checkLiteratureNote(note: object): object[];
 /** The `lore` subType whose notes are works of literature. */
 export const LITERATURE_SUBTYPE: "literature";
+/** The `lore` subTypes that may name a language. */
+export const LANGUAGE_SUBTYPES: readonly string[];
 /**
- * The fields only a `literature` note may state. Every one is optional.
+ * `data.language`: the tongue a work is composed in, or the tongue a culture's
+ * people speak. Optional on both.
+ *
+ * @type {object}
+ */
+export const LANGUAGE_FIELD: object;
+/**
+ * The fields only a `literature` note may state, beside the shared
+ * {@link LANGUAGE_FIELD}. Every one is optional.
  *
  * @type {ReadonlyArray<object>}
  */

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/npc-generate.d.mts

@@ -0,0 +1,124 @@
+/**
+ * A value as JSON with every map's keys sorted, so two specs stating the same
+ * fields in a different order serialise alike.
+ *
+ * @param {unknown} value - A spec, or any value in one.
+ * @returns {string} The canonical serialisation.
+ */
+export function canonicalSpec(value: unknown): string;
+/**
+ * Why a spec cannot be generated from, or nothing.
+ *
+ * @param {unknown} spec - The spec as read.
+ * @returns {string[]} One sentence per problem.
+ */
+export function npcSpecProblems(spec: unknown): string[];
+/**
+ * The shortcode a name derives, free of every shortcode in `taken`.
+ *
+ * @param {string} name - `name.full`.
+ * @param {ReadonlySet<string>} taken - Shortcodes the package's beings hold.
+ * @returns {string} The shortcode.
+ */
+export function npcShortcode(name: string, taken: ReadonlySet<string>): string;
+/**
+ * The Appearance section's paragraph, in the Folk wording: "Ahmetega Zekar is
+ * a 39-year-old man who stands 6'4" tall with a heavy build. He has tawny
+ * skin, weathered complexion, black hair, and brown eyes."
+ *
+ * A fact that is absent leaves its clause out.
+ *
+ * @param {object} facts
+ * @param {string} facts.name - `name.full`.
+ * @param {number|null} [facts.age] - Whole years, or `null` where unknown.
+ * @param {string} [facts.gender]
+ * @param {unknown} [facts.height]
+ * @param {string} [facts.frame]
+ * @param {object} [facts.appearance] - The `data.appearance` map.
+ * @returns {string} The paragraph.
+ */
+export function appearanceParagraph({ name, age, gender, height, frame, appearance }: {
+    name: string;
+    age?: number | null | undefined;
+    gender?: string | undefined;
+    height?: unknown;
+    frame?: string | undefined;
+    appearance?: object | undefined;
+}): string;
+/**
+ * Generate a being note from a spec.
+ *
+ * @param {object} spec - The spec: frontmatter fields, plus `appearance` and
+ *   `dossier` section bodies.
+ * @param {object} context
+ * @param {object} context.profile - The culture's appearance profile, already
+ *   checked by `profileProblems`.
+ * @param {object} context.names - The language's `data.names`, already checked
+ *   by `namesProblems`.
+ * @param {string} [context.language] - The language's Address, for an error
+ *   about a name that does not fit.
+ * @param {string} [context.seed] - Text joined to the spec's own seed, to draw a
+ *   different person from the same spec.
+ * @param {unknown} [context.present] - The package's present, or `null`.
+ * @param {object} [context.dateContext] - The reckoning context the present
+ *   and `born` are read in, with `daysPerYear`.
+ * @param {{icon?: unknown, species?: unknown, packFolder?: unknown}} [context.defaults] -
+ *   Values derived from the package's other beings.
+ * @param {ReadonlySet<string>} [context.taken] - Shortcodes the package's beings hold.
+ * @returns {{frontmatter: object, body: string, text: string}} The note.
+ * @throws {Error} Where the spec has problems, or states a `name.full` that
+ *   does not fit the language's lists; that error carries `keyPath`
+ *   `["name", "full"]`.
+ */
+export function generateNpc(spec: object, context: {
+    profile: object;
+    names: object;
+    language?: string | undefined;
+    seed?: string | undefined;
+    present?: unknown;
+    dateContext?: object | undefined;
+    defaults?: {
+        icon?: unknown;
+        species?: unknown;
+        packFolder?: unknown;
+    } | undefined;
+    taken?: ReadonlySet<string> | undefined;
+}): {
+    frontmatter: object;
+    body: string;
+    text: string;
+};
+/**
+ * The canonical Address a `data.culture` value names, read as a culture
+ * reference is: a `lore` note in this package unless it says otherwise.
+ *
+ * @param {unknown} value - The value as written, or a decoded tuple.
+ * @param {object} index - The link index.
+ * @returns {string|undefined} The Address, or `undefined` where it reads as none.
+ */
+export function cultureKey(value: unknown, index: object): string | undefined;
+/**
+ * The commonest value of each of `icon`, `species` and `packFolder` among the
+ * package's npcs, as their notes write it: those of the same culture first,
+ * then any npc. A tie goes to the value that sorts first.
+ *
+ * @param {object} index - The link index.
+ * @param {string|undefined} culture - The culture's canonical Address.
+ * @returns {{icon?: unknown, species?: unknown, packFolder?: unknown, taken: Set<string>}}
+ *   The defaults, and the shortcodes the package's beings hold.
+ */
+export function npcDefaults(index: object, culture: string | undefined): {
+    icon?: unknown;
+    species?: unknown;
+    packFolder?: unknown;
+    taken: Set<string>;
+};
+/** The youngest and oldest age, in whole years, a generated person is born to. */
+export const ADULT_AGE: Readonly<{
+    min: 18;
+    max: 60;
+}>;
+/** The longest shortcode the derivation makes. */
+export const SHORTCODE_LENGTH: 12;
+/** The spec fields `npc new` requires, as paths. */
+export const REQUIRED_SPEC_FIELDS: readonly string[];

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[]>;
+};