@heroiclands/package-build 22.4.5 → 22.4.7

package/types/engine/holdings.d.mts

@@ -0,0 +1,146 @@
+/**
+ * Read a local note into a node, or `null` for a note that takes no part.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {object} page - The page it publishes as.
+ * @param {string} page.title - Its published title.
+ * @param {string} page.url - Its URL.
+ * @returns {HoldingsNode|null} The node, or `null` for a note that is neither
+ *   a place nor an affiliation, or that declares no shortcode.
+ */
+export function holdingsNode(fm: object, { title, url }: {
+    title: string;
+    url: string;
+}): HoldingsNode | null;
+/**
+ * Read a fetched index's places and affiliations as nodes.
+ *
+ * An entry carries what the producer's record stated — its name, `subType`,
+ * `parents` and `domains` — and its page URL where the package publishes one.
+ *
+ * @param {Map<string, object>|undefined} foreignIndex - As
+ *   {@link module:engine/metadata-index.loadForeignIndexes} returns it.
+ * @returns {HoldingsNode[]} The nodes, in index order.
+ */
+export function foreignHoldingsNodes(foreignIndex: Map<string, object> | undefined): HoldingsNode[];
+/**
+ * Invert `parents` and `domains` into each page's lists.
+ *
+ * A shortcode is declared once per type: the first node declaring it wins,
+ * so local nodes handed in ahead of fetched ones shadow a dependency's, the
+ * way the link resolver answers. A node with no URL is nobody's entry and
+ * carries no lists of its own, since there is no page to write them on. A
+ * name no node declares is dropped: a `parents` naming nowhere is the map's
+ * finding, a `domains` naming nowhere the reference check's.
+ *
+ * The result holds only pages with at least one entry on at least one list,
+ * and a page's block carries only the keys it has entries for — the theme's
+ * silent-disappear convention, kept at the source.
+ *
+ * @param {Iterable<HoldingsNode|null>} nodes - Every place and affiliation,
+ *   local first. `parents` and `domains` are read as written, so a node
+ *   built by hand may carry them as the note spells them.
+ * @returns {Map<string, Holdings>} URL → the page's lists, sorted.
+ */
+export function holdingsPages(nodes: Iterable<HoldingsNode | null>): Map<string, Holdings>;
+/**
+ * Check a place note's tenure: a settlement, a site or a structure that no
+ * affiliation's `domains` names is unheld land, reported as a warning at the
+ * note's `type:` line.
+ *
+ * Declared on the `place` vocabulary as its type-level check, so the lint
+ * runs it beside the field checks with the same index. Without an index the
+ * question cannot be asked and 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 every affiliation.
+ * @returns {object[]} Findings.
+ */
+export function checkHeld(note: object, { index }?: {
+    index?: object | undefined;
+}): object[];
+/**
+ * The keys this module writes, and which a note cannot author: `contains`
+ * and `held_by` on a place, `holdings` on an affiliation.
+ *
+ * @type {readonly string[]}
+ */
+export const HOLDINGS_KEYS: readonly string[];
+/**
+ * The place subTypes tenure is checked on. A region is held through its
+ * polity's `domains`, a world by nobody, a feature by nobody — a river has no
+ * lord — so the rest are the kinds of place a body holds directly.
+ *
+ * @type {readonly string[]}
+ */
+export const HELD_SUBTYPES: readonly string[];
+/**
+ * One entry of a holdings list — a page a reader is pointed at.
+ */
+export type HoldingsEntry = {
+    /**
+     * The page's published title.
+     */
+    title: string;
+    /**
+     * `<base><slug>/` — the page's address as every
+     * href this build renders composes it.
+     */
+    url: string;
+    /**
+     * The note's `type` — `place` or `affiliation`.
+     */
+    type: string;
+    /**
+     * The note's `subType`, where it declares one.
+     */
+    subType?: string | undefined;
+};
+/**
+ * One place or affiliation, as the derivation reads it — a local page or a
+ * fetched index entry through one shape.
+ */
+export type HoldingsNode = {
+    /**
+     * Lower case.
+     */
+    shortcode: string;
+    type: "place" | "affiliation";
+    subType?: string | undefined;
+    /**
+     * The page's published title.
+     */
+    title: string;
+    /**
+     * The page's URL; absent where the package
+     *      publishes no page for it.
+     */
+    url?: string | undefined;
+    /**
+     * What a place sits within, as written.
+     */
+    parents: string[];
+    /**
+     * What an affiliation holds, as written.
+     */
+    domains: string[];
+};
+/**
+ * The lists one page carries. Every key is optional, and a key present holds
+ * at least one entry.
+ */
+export type Holdings = {
+    /**
+     * Places whose `parents` name this one.
+     */
+    contains?: HoldingsEntry[] | undefined;
+    /**
+     * Affiliations whose `domains` name this one.
+     */
+    held_by?: HoldingsEntry[] | undefined;
+    /**
+     * Places this affiliation's `domains` name.
+     */
+    holdings?: HoldingsEntry[] | undefined;
+};

package/types/engine/index.d.mts

@@ -16,11 +16,14 @@ export * as homepage from "./homepage.mjs";
 export * as noteSchemas from "./note-schemas.mjs";
 export * as noteVocabulary from "./note-vocabulary.mjs";
 export * as placeRelations from "./place-relations.mjs";
+export * as holdings from "./holdings.mjs";
+export * as marketClass from "./market-class.mjs";
 export * as mapPlaces from "./map-places.mjs";
 export * as mapLayout from "./map-layout.mjs";
 export * as mapDot from "./map-dot.mjs";
 export * as mapGraphviz from "./map-graphviz.mjs";
 export * as mapBuild from "./map-build.mjs";
+export * as siteMaps from "./site-maps.mjs";
 export * as systems from "./systems.mjs";
 export * as contentSlug from "./content-slug.mjs";
 export * as contentAddress from "./content-address.mjs";

package/types/engine/map-build.d.mts

@@ -1,6 +1,6 @@
 /**
  * Every place that states, or is named in, a border or a route — the places
- * `--from all` draws.
+ * `--from all` and `--chart all` draw.
  *
  * @param {Map<string, import("./map-places.mjs").MapPlace>} places - Every place.
  * @returns {string[]} Shortcodes, sorted.
@@ -17,10 +17,14 @@ export function relatedPlaces(places: Map<string, import("./map-places.mjs").Map
  * @param {string} [opts.root] - With `tree`, the subtree beneath this place.
  * @param {string[]} [opts.from] - Draw the map from each of these places, or
  *   from every related place for {@link FROM_ALL}.
+ * @param {string[]} [opts.chart] - Draw the chart from each of these places,
+ *   or from every related place for {@link FROM_ALL}.
+ * @param {number} [opts.horizon] - The charts' horizon in days, a marker of
+ *   the scale; the end of the scale by default.
  * @param {boolean} [opts.travel] - Draw the whole route graph.
  * @param {string} [opts.engine="dot"] - The tree's engine: `dot`, `twopi` or
- *   `neato`. The map from a place is always `neato` with every node pinned,
- *   and the route graph always `neato`.
+ *   `neato`. The map and the chart from a place are always `neato` with
+ *   every node pinned, and the route graph always `neato`.
  * @param {string} [opts.rankdir="TB"] - The tree's rank direction, `dot` only.
  * @param {number} [opts.nodesep] - The tree's `nodesep`, inches.
  * @param {number} [opts.ranksep] - The tree's `ranksep`, inches.
@@ -35,15 +39,17 @@ export function relatedPlaces(places: Map<string, import("./map-places.mjs").Map
  *   column?: number, severity: "error"|"warning", message: string}>,
  *   skipped: boolean}} What was written, what was found, and whether the
  *   rendering was skipped for want of GraphViz.
- * @throws {Error} When no mode is asked for, a named place is not one, or
- *   GraphViz is required and absent.
+ * @throws {Error} When no mode is asked for, a named place is not one, the
+ *   horizon is not a marker of the scale, or GraphViz is required and absent.
  */
-export function buildMaps({ world, outDir, tree, root, from, travel, engine, rankdir, nodesep, ranksep, scale, polities, locate, requireGraphviz, }: {
+export function buildMaps({ world, outDir, tree, root, from, chart, horizon, travel, engine, rankdir, nodesep, ranksep, scale, polities, locate, requireGraphviz, }: {
     world: import("./map-places.mjs").MapWorld;
     outDir: string;
     tree?: boolean | undefined;
     root?: string | undefined;
     from?: string[] | undefined;
+    chart?: string[] | undefined;
+    horizon?: number | undefined;
     travel?: boolean | undefined;
     engine?: string | undefined;
     rankdir?: string | undefined;
@@ -71,7 +77,7 @@ export function buildMaps({ world, outDir, tree, root, from, travel, engine, ran
  */
 export const MAP_DIR: string;
 /**
- * The value of `--from` that means every place with a relation.
+ * The value of `--from` or `--chart` that means every place with a relation.
  *
  * @type {string}
  */

package/types/engine/map-dot.d.mts

@@ -1,3 +1,12 @@
+/**
+ * The opacity of a place by its hop count: the neighbours and the second hop
+ * are drawn full — the second in the dim palette — and each hop beyond
+ * steps down, never below the floor.
+ *
+ * @param {number} hop - 1 for a neighbour, 2 and up beyond.
+ * @returns {number} 0 to 1.
+ */
+export function hopOpacity(hop: number): number;
 /**
  * A DOT double-quoted string.
  *
@@ -45,24 +54,28 @@ export function treeDot({ places, polities, analysis, root, title, engine, rankd
     drawPolities?: boolean | undefined;
 }): string;
 /**
- * The map from a place as DOT, for `neato -n2`.
+ * The map from a place, or the chart from one, as DOT for `neato -n2`.
  *
  * Every node is pinned at the position the layout computed, so the engine
  * only draws. The rings are circles pinned at the origin, drawn faintly,
- * each labelled with its days marker at the top; the rim is one more. The
- * centre is drawn in its `subType` style at full size, a neighbour at the
- * layout's scale, and a second hop dimmer. A place beyond the horizon or
- * with unknown days is a name at the rim, its label carrying its days or `?`.
- * A border edge is dashed; every edge is labelled with its bearing and days.
+ * each labelled with its days marker at the top; the rim is one more,
+ * labelled `beyond` where the layout names what lies past the horizon there
+ * and `unknown` where it holds only the places whose days nobody stated.
+ * The centre is drawn in its `subType` style at full size, a neighbour at
+ * the layout's scale, a second hop dimmer, and each hop beyond fainter
+ * still, down to a floor. A place at the rim is a name, its label carrying
+ * its days or `?`. A border edge is dashed; every edge is labelled with its
+ * bearing and days, and dimmed with its far end.
  *
- * @param {ReturnType<typeof import("./map-layout.mjs").layoutFrom>} layout - The layout.
+ * @param {import("./map-layout.mjs").FromLayout} layout - The layout.
  * @param {Map<string, import("./map-places.mjs").MapPlace>} places - Every place.
  * @param {object} [opts]
  * @param {number} [opts.scale=1] - Multiplies every size.
- * @param {string} [opts.title] - Defaults to `From <name>`.
+ * @param {string} [opts.title] - Defaults to `From <name>`, or to
+ *   `Chart from <name>` for a layout with no rim beyond the horizon.
  * @returns {string} The DOT text.
  */
-export function fromDot(layout: ReturnType<typeof import("./map-layout.mjs").layoutFrom>, places: Map<string, import("./map-places.mjs").MapPlace>, { scale, title }?: {
+export function fromDot(layout: import("./map-layout.mjs").FromLayout, places: Map<string, import("./map-places.mjs").MapPlace>, { scale, title }?: {
     scale?: number | undefined;
     title?: string | undefined;
 }): string;

package/types/engine/map-graphviz.d.mts

@@ -21,7 +21,7 @@ export function findGraphviz(engine: string, { env, fallbacks }?: {
 }): string | undefined;
 /**
  * What to say when an engine is not installed: the name, and what installs
- * it on the two platforms a contributor is likely to be on.
+ * it.
  *
  * @param {string} engine - The engine that was wanted.
  * @returns {string} The message.
@@ -59,3 +59,10 @@ export function renderDot(dotPath: string, outPath: string, { binary, format, ar
  * @type {readonly string[]}
  */
 export const GRAPHVIZ_ENGINES: readonly string[];
+/**
+ * What installs GraphViz on the two platforms a contributor is likely to be
+ * on, as the clause every "not installed" message ends with.
+ *
+ * @type {string}
+ */
+export const GRAPHVIZ_INSTALL: string;

package/types/engine/map-layout.d.mts

@@ -34,26 +34,32 @@ export function bearingSteps(a: unknown, b: unknown): number | undefined;
  * days nobody stated, is named. One log step beyond the horizon, so the rim
  * reads as the next ring rather than a margin.
  *
+ * @param {number} [horizon] - The horizon in days; the map from a place's
+ *   by default.
  * @returns {number} Points.
  */
-export function rimRadius(): number;
+export function rimRadius(horizon?: number): number;
 /**
  * The radius of the ring a days value sits on.
  *
  * Logarithmic in days, so equal ratios of days are equal steps of radius: a
- * day to two days is the same step as five to ten. Any value beyond the
- * horizon, and no value at all, is the rim.
+ * day to two days is the same step as five to ten, whatever the horizon. Any
+ * value beyond the horizon, and no value at all, is the rim.
  *
  * @param {number|undefined} days - A days value, on the scale or not.
+ * @param {number} [horizon] - The horizon in days; the map from a place's
+ *   by default.
  * @returns {number} Points.
  */
-export function ringRadius(days: number | undefined): number;
+export function ringRadius(days: number | undefined, horizon?: number): number;
 /**
  * The rings, inside out — one per marker up to the horizon.
  *
+ * @param {number} [horizon] - The horizon in days; the map from a place's
+ *   by default.
  * @returns {Array<{days: number, radius: number}>} Each marker and its radius.
  */
-export function rings(): Array<{
+export function rings(horizon?: number): Array<{
     days: number;
     radius: number;
 }>;
@@ -79,24 +85,37 @@ export function daysMarker(total: number | undefined): number | undefined;
  */
 export function edgeLength(days: number | undefined): number;
 /**
- * One hop of a journey: a bearing and, for a route, its days.
+ * A chain of hops composed into one bearing and one total, or nothing where
+ * a hop turns back.
+ *
+ * The composed direction is that of the hops added as vectors weighted by
+ * their days, and the total is their sum. Each hop after the first is
+ * checked against the running direction of the chain before it — not
+ * against the previous hop — and composes only where it lies within one
+ * octant of that direction, so a path may bend a little at every hop and
+ * drift past an octant of where it began, but a hop that turns back ends
+ * the chain: a place east and then north of here is not in any one
+ * direction, and the drawing omits it rather than guess. A hop with no days
+ * — a border — makes the total unknown, because a frontier states no
+ * distance, and then every hop weighs the same, because nothing says which
+ * is the longer.
  *
- * @typedef {object} Hop
- * @property {string} bearing - Where the far end lies from the near end.
- * @property {number} [days] - The route's marker; absent for a border.
+ * @param {Hop[]} hops - The hops, from the centre outward.
+ * @returns {{angle: number, days: number|undefined}|undefined} The composed
+ *   bearing in degrees and the total days, or `undefined` where a hop turns
+ *   back, a bearing is not one, or there are no hops.
  */
+export function composeChain(hops: Hop[]): {
+    angle: number;
+    days: number | undefined;
+} | undefined;
 /**
  * Two hops composed into one bearing and one total, or nothing where they
  * disagree.
  *
- * Two hops agree when their bearings are the same or adjacent; then the
- * composed direction is that of the two hops added as vectors weighted by
- * their days, and the total is their sum. A hop with no days — a border —
- * makes the total unknown, because a frontier states no distance, and then
- * the two hops weigh the same, because nothing says which is the longer.
- * Hops two or more steps apart do not compose:
- * a place east and then north of here is not in any one direction, and the
- * map omits it rather than guess.
+ * Two hops agree when their bearings are the same or adjacent — the
+ * two-hop case of {@link composeChain}: the second hop is checked against
+ * the first, which is the whole running direction at that point.
  *
  * @param {Hop} first - The hop from the centre.
  * @param {Hop} second - The hop onward.
@@ -133,7 +152,8 @@ export function relationsOf(places: Map<string, MapPlace>, shortcode: string): {
     }>;
 };
 /**
- * Lay out the map from a place.
+ * Lay out the map from a place: two hops, a horizon of 90 days, and a rim
+ * naming what lies beyond it.
  *
  * The centre at the origin. Every neighbour it states, or that states it, at
  * the angle of its bearing and on the ring of its days — the innermost ring
@@ -147,25 +167,35 @@ export function relationsOf(places: Map<string, MapPlace>, shortcode: string): {
  *
  * @param {Map<string, MapPlace>} places - Every place, by shortcode.
  * @param {string} centre - The place the map is from.
- * @returns {{centre: string, nodes: FromNode[], edges: FromEdge[],
- *   rings: Array<{days: number, radius: number}>, rim: number,
- *   unresolved: Array<{from: string, to: string}>}} The layout, in points.
+ * @returns {FromLayout} The layout, in points.
  * @throws {Error} When `centre` is not a place.
  */
-export function layoutFrom(places: Map<string, MapPlace>, centre: string): {
-    centre: string;
-    nodes: FromNode[];
-    edges: FromEdge[];
-    rings: Array<{
-        days: number;
-        radius: number;
-    }>;
-    rim: number;
-    unresolved: Array<{
-        from: string;
-        to: string;
-    }>;
-};
+export function layoutFrom(places: Map<string, MapPlace>, centre: string): FromLayout;
+/**
+ * Lay out the chart from a place: the map from it at a larger horizon.
+ *
+ * The neighbours as on the map from a place. Beyond them the hops chain on,
+ * each checked against the running direction of the chain so far and
+ * composing only within one octant of it, so a path bends but never turns
+ * back; a place is drawn at the composed bearing on the ring of the summed
+ * days, and where several chains reach it, by the one with the fewest. A
+ * border beyond the first hop makes the total unknown and sends the place to
+ * the rim, and nothing is drawn beyond it. A place whose total exceeds the
+ * horizon is left out — the chart is already the larger view — so the rim
+ * holds the unknown alone.
+ *
+ * @param {Map<string, MapPlace>} places - Every place, by shortcode.
+ * @param {string} centre - The place the chart is from.
+ * @param {object} [opts]
+ * @param {number} [opts.horizon] - The horizon in days, a marker of the
+ *   scale; {@link CHART_HORIZON_DAYS} by default.
+ * @returns {FromLayout} The layout, in points.
+ * @throws {Error} When `centre` is not a place, or `horizon` is not a marker
+ *   of the scale.
+ */
+export function layoutChart(places: Map<string, MapPlace>, centre: string, { horizon }?: {
+    horizon?: number | undefined;
+}): FromLayout;
 /**
  * One edge of the whole route graph.
  *
@@ -213,18 +243,12 @@ export const HORIZON_DAYS: number;
  */
 export const RING_DAYS: readonly number[];
 /**
- * One hop of a journey: a bearing and, for a route, its days.
+ * The horizon of the chart from a place when none is asked for, in days: the
+ * end of the scale, so the whole of what the notes state fits on the page.
+ *
+ * @type {number}
  */
-export type Hop = {
-    /**
-     * - Where the far end lies from the near end.
-     */
-    bearing: string;
-    /**
-     * - The route's marker; absent for a border.
-     */
-    days?: number | undefined;
-};
+export const CHART_HORIZON_DAYS: number;
 /**
  * A place as the map reads it. The shape {@link module :engine/map-places}
  * builds from the content index; only the relation fields matter here.
@@ -265,6 +289,35 @@ export type Relation = {
      */
     stated: boolean;
 };
+/**
+ * The layout of the map from a place or of the chart from one.
+ */
+export type FromLayout = {
+    centre: string;
+    nodes: FromNode[];
+    edges: FromEdge[];
+    rings: Array<{
+        days: number;
+        radius: number;
+    }>;
+    /**
+     * - The rim's radius, in points.
+     */
+    rim: number;
+    /**
+     * - The horizon, in days.
+     */
+    horizon: number;
+    /**
+     * - Whether a place past the horizon is named at
+     * the rim; false, it is omitted and the rim holds only the unknown.
+     */
+    beyond: boolean;
+    unresolved: Array<{
+        from: string;
+        to: string;
+    }>;
+};
 /**
  * One edge of the whole route graph.
  */
@@ -283,13 +336,27 @@ export type TravelEdge = {
      */
     len: number;
 };
+/**
+ * One hop of a journey: a bearing and, for a route, its days.
+ */
+export type Hop = {
+    /**
+     * - Where the far end lies from the near end.
+     */
+    bearing: string;
+    /**
+     * - The route's marker; absent for a border.
+     */
+    days?: number | undefined;
+};
 /**
  * One place on the map from a place.
  */
 export type FromNode = {
     shortcode: string;
     /**
-     * - 0 for the centre, 1 for a neighbour, 2 beyond.
+     * - 0 for the centre, 1 for a neighbour, 2 and up
+     * beyond — the map from a place stops at 2, the chart goes on.
      */
     hop: number;
     /**
@@ -321,7 +388,8 @@ export type FromNode = {
      */
     unknown: boolean;
     /**
-     * - The neighbour a second hop is reached through.
+     * - The place a hop beyond the neighbours is reached
+     * through.
      */
     via?: string | undefined;
 };
@@ -353,7 +421,7 @@ export type FromEdge = {
         days: number | undefined;
     }>;
     /**
-     * - 1 from the centre, 2 onward.
+     * - 1 from the centre, 2 and up onward.
      */
     hop: number;
 };

package/types/engine/map-places.d.mts

@@ -34,6 +34,32 @@ export function loadMapWorld({ config, contentBase, base, problems }: {
     base?: string | undefined;
     problems?: object[] | undefined;
 }): MapWorld;
+/**
+ * The world a map is drawn from, out of records and indexes a caller already
+ * holds: this package's places from its index records, and every
+ * dependency's from the fetched indexes. The site build reads its corpus and
+ * its foreign indexes once for every surface it publishes, and hands them
+ * here rather than walking the tree a second time.
+ *
+ * @param {object} opts
+ * @param {Array<Record<string, any>>} opts.records - Index records, as
+ *   {@link module:engine/content-index.indexRecordsFor} returns them.
+ * @param {Map<string, object>} opts.foreignIndex - The fetched indexes, as
+ *   {@link module:engine/metadata-index.loadForeignIndexes} returns `index`.
+ * @param {string} opts.contentBase - The content root the records were read from.
+ * @param {string} [opts.base] - The site base this package's pages are served
+ *   under. Absent, no local place carries a URL.
+ * @param {object} opts.config - The resolved configuration.
+ * @returns {MapWorld} The world, with nothing stale: the caller has already
+ *   judged its indexes usable.
+ */
+export function mapWorld({ records, foreignIndex, contentBase, base, config }: {
+    records: Array<Record<string, any>>;
+    foreignIndex: Map<string, object>;
+    contentBase: string;
+    base?: string | undefined;
+    config: object;
+}): MapWorld;
 /**
  * Analyse the containment tree.
  *

package/types/engine/market-class.d.mts

@@ -0,0 +1,62 @@
+/**
+ * Whether a value is one of the classes the scale states.
+ *
+ * A note may write the number quoted, which YAML hands over as a string, so
+ * the value is read as a number before it is compared — the same reading
+ * `matchesKind` gives a `number` field.
+ *
+ * @param {unknown} value - The authored value.
+ * @returns {boolean} Whether it names a class.
+ */
+export function isMarketClass(value: unknown): boolean;
+/**
+ * The class a value names, or `undefined` for a value that names none.
+ *
+ * @param {unknown} value - The authored value.
+ * @returns {MarketClass|undefined} The class.
+ */
+export function marketClass(value: unknown): MarketClass | undefined;
+/**
+ * Check a place note's `data.market`.
+ *
+ * The value is one of the classes the scale states, or it is a finding located
+ * at the key's own line. A value that is not a number at all is left alone:
+ * the container's own shape check reports it, and saying so twice would make
+ * one slip read as two.
+ *
+ * @param {object} note - The note, as the link index hands it over.
+ * @returns {object[]} Findings.
+ */
+export function checkMarket(note: object): object[];
+/**
+ * One step of the market scale.
+ *
+ * @typedef {object} MarketClass
+ * @property {number} value - The integer a note writes.
+ * @property {string} name - What a settlement of this class is called.
+ * @property {string} trade - What can be had there.
+ */
+/**
+ * The market scale, in order, from the settlement with no market to the one
+ * other markets buy from.
+ *
+ * @type {readonly MarketClass[]}
+ */
+export const MARKET_CLASSES: readonly MarketClass[];
+/**
+ * One step of the market scale.
+ */
+export type MarketClass = {
+    /**
+     * - The integer a note writes.
+     */
+    value: number;
+    /**
+     * - What a settlement of this class is called.
+     */
+    name: string;
+    /**
+     * - What can be had there.
+     */
+    trade: string;
+};

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

@@ -344,4 +344,14 @@ export type TypeVocabulary = {
      * values, as above.
      */
     subTypes?: readonly string[] | null | undefined;
+    /**
+     * - A
+     * check of the whole note, run by the frontmatter lint beside the field
+     * checks with the same index. For a rule that is about the note rather than
+     * one of its fields — a place's tenure is a fact about every affiliation's
+     * `domains`, and is located at the note's `type:` line.
+     */
+    check?: ((note: object, opts: {
+        index?: object;
+    }) => object[]) | undefined;
 };