@heroiclands/package-build 25.5.5 → 25.6.0

package/sohl/actors.mjs

@@ -42,7 +42,8 @@
  * **A membership is derived, never authored here.** `data.affiliations` names
  * the bodies a being belongs to and the standing it holds in each, and each
  * entry becomes one embedded affiliation item: the entry's `rank` is that
- * item's `system.level`, its `office` is `system.office`, and the first of its
+ * item's `system.level`, its `office` is `system.office` (several posts joined
+ * by commas), and the first of its
  * `societies` is `system.society`, the one society the SoHL item carries. A
  * standing is a fact about the setting rather than about one system — it does
  * not become true because SoHL is installed — so the system block states none
@@ -76,7 +77,7 @@ import { blockProperty, mergeSystemData } from "../engine/system-block.mjs";
 // A being's memberships and the standing it holds in each, read from the one
 // place they are authored. The rank *is* the affiliation item's `level`, so
 // there is nothing to map and nowhere for a second authoring to disagree.
-import { readStandings } from "../engine/standings.mjs";
+import { readStandings, standingOffices } from "../engine/standings.mjs";
 
 /**
  * The system this pass compiles for — the block its notes write.
@@ -234,7 +235,7 @@ export class Actors extends SystemActorCompiler {
             const shortcode = body?.shortcode;
             if (!shortcode) continue;
             const level = Number(standing?.rank);
-            const office = typeof standing?.office === "string" ? standing.office.trim() : "";
+            const office = standingOffices(standing).join(", ");
             const [first] = Array.isArray(standing?.societies) ? standing.societies : [];
             const society = typeof first === "string" ? first.trim() : "";
             const system = {

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

@@ -74,7 +74,8 @@ export function lintContentHtml(contentBase: string, { skipDirectories, sources
  * markdown's own angle brackets out of it: an autolink is `<https://…>`, and
  * `https` is followed by `:` rather than whitespace or `>`, so the pattern
  * stops. A comparison written in prose — `a < b` — has no name after the
- * bracket at all.
+ * bracket at all. A doubled `<<` opens a quotation, so its second bracket
+ * never starts an HTML tag.
  *
  * Attributes are consumed as "anything but a bracket", deliberately loosely: a
  * finding names the tag, and a pattern that tried to parse attribute syntax

package/types/engine/culture-reach.d.mts

@@ -42,6 +42,9 @@ export function noteTerms(index: object, note: object, entry?: object): Map<stri
  * in a tree that describes peoples. Its ranks and offices then have no
  * culture associations for term queries.
  *
+ * The note's `data.culture` is the culture the content index resolved for it:
+ * its own, else the one its `data.parents` chain agrees on.
+ *
  * @param {object} note - An `affiliation` note.
  * @param {{index?: object}} [context]
  * @returns {object[]} One warning, at the note's `type`, or none.

package/types/engine/declared-sections.d.mts

@@ -0,0 +1,30 @@
+/** Authored headings, excluding literal examples and named containers. */
+export function declaredHeadings(markdown: any, syntax: any): {
+    level: number;
+    line: number;
+    text: string;
+    id: string;
+    classes: string[];
+    values: Record<string, string>;
+}[];
+/**
+ * Insert indexed content at its heading while preserving subsequent source lines.
+ * @param {string} markdown - Expanded body.
+ * @param {Array<{slug:string,heading:string,markdown:string}>} [sections] - Declared content.
+ * @param {{authored?:string,lineMap?:object[],generatedFrom?:number,syntax?:Function}} [context] - Captured source mappings.
+ * @returns {{markdown:string,lineMap:object[],generatedFrom?:number}} Expanded body and locations.
+ */
+export function insertDeclaredSections(markdown: string, sections?: Array<{
+    slug: string;
+    heading: string;
+    markdown: string;
+}>, { authored, lineMap, generatedFrom, syntax }?: {
+    authored?: string;
+    lineMap?: object[];
+    generatedFrom?: number;
+    syntax?: Function;
+}): {
+    markdown: string;
+    lineMap: object[];
+    generatedFrom?: number;
+};

package/types/engine/derived-sections.d.mts

@@ -51,15 +51,19 @@ export function drawMapsFrom(records: object[], { outDir, foreignIndex, config,
  *   prepared results are keyed.
  * @param {Map<string, object>} [opts.foreignIndex] - The fetched indexes.
  * @param {object} [opts.config] - The resolved configuration.
+ * @param {(file:string)=>string|undefined} [opts.rawOf] - Captured source locators.
+ * @param {object[]} [opts.all=records] - Complete records for settlement validation.
  * @param {string} [opts.only] - One note file to give sections to; absent,
  *   every note.
  * @returns {Map<string, Map<string, string>>} Note file to its sections, each
  *   keyed by its slug, for every note given at least one.
  */
-export function derivedSections(records: object[], { fileOf, foreignIndex, config, only }: {
+export function derivedSections(records: object[], { fileOf, foreignIndex, config, only, rawOf, all }: {
     fileOf: (record: object) => string;
     foreignIndex?: Map<string, object> | undefined;
     config?: object | undefined;
+    rawOf?: ((file: string) => string | undefined) | undefined;
+    all?: object[] | undefined;
     only?: string | undefined;
 }): Map<string, Map<string, string>>;
 /**

package/types/engine/holdings.d.mts

@@ -47,13 +47,45 @@ export function foreignHoldingsNodes(foreignIndex: Map<string, object> | undefin
 export function holdingsPages(nodes: Iterable<HoldingsNode | null>, { governmentNodes }?: {
     governmentNodes?: Iterable<HoldingsNode | null> | undefined;
 }): Map<string, Holdings>;
+/**
+ * Whether a record's `data.government` came from a parent rather than its own
+ * note.
+ *
+ * @param {object} record - An index record.
+ * @returns {boolean} True for a district that inherited its government.
+ */
+export function governmentInherited(record: object): boolean;
+/**
+ * Give each district that states no government its parent's.
+ *
+ * A `place/district` falls under the government of the place it stands
+ * within. One stating no `data.government` key takes the value of its nearest
+ * parent that states the key, walking `data.parents` breadth first, in the
+ * order written, through any parent that states none, and never visiting a
+ * place twice. An explicit value on the district, `null` (complete anarchy)
+ * included, is its own and is kept; a parent's explicit `null` is inherited as
+ * anarchy. Every reader of the index — the Governed by and Governed places
+ * sections, the "missing government" advisory, a consumer of the published
+ * index — then reads the effective government at `data.government`.
+ *
+ * @param {object[]} records - Content-index records, edited in place.
+ * @param {object} [opts]
+ * @param {(key: string) => object|undefined} [opts.foreignRecord] - A fetched
+ *   index's record by canonical Address, for a parent in a dependency.
+ * @returns {void}
+ */
+export function inheritDistrictGovernments(records: object[], { foreignRecord }?: {
+    foreignRecord?: ((key: string) => object | undefined) | undefined;
+}): void;
 /**
  * Advise when a place with an authored positive population omits government.
  * Missing, null or zero population establishes no inhabited population.
  * Property presence distinguishes omitted government from explicit null,
  * which means complete anarchy. Non-null values are validated by the declared
- * affiliation reference field. Neither geographic containment nor tenure
- * supplies this fact, and the rule is independent of place subtype.
+ * affiliation reference field. Tenure never supplies this fact, and
+ * containment supplies it only to a district, which the content index gives
+ * its nearest parent's government (see {@link inheritDistrictGovernments}), so
+ * a district under a governed place is never advised.
  *
  * @param {object} note - The note with parsed frontmatter and raw source.
  * @returns {object[]} Located warning findings.

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

@@ -122,7 +122,8 @@ export function recordPath(record: Record<string, any>): string;
  * since a note declaring its own is a hard error — and it matches what
  * the content-table expander puts on the same field, so a query reads the same
  * value from either. `file` namespaces the note's place in the tree, again
- * matching the expander's `file.*`.
+ * matching the expander's `file.*`. `officeHolders` lists, on a body, the
+ * living beings whose own standing names each of its offices.
  *
  * Both are checked rather than assumed: `folder` is real frontmatter on most
  * notes, so the neighbouring names are close enough to a real key that a silent

package/types/engine/language-terms.d.mts

@@ -94,7 +94,11 @@ export const JOIN_MEETINGS: readonly string[];
  * letters between, `drop` loses the first, `double` doubles the consonant.
  */
 export const JOIN_RULES: readonly string[];
-/** What a written mark says of its letter. */
+/**
+ * What a written mark says of its letter: `stress` falls on it, `length` holds
+ * it longer, `apart` says it apart from its neighbour, and `quality` changes
+ * which vowel is said.
+ */
 export const MARK_KINDS: readonly string[];
 /** How many of a mark a word may carry: `one` at most, or `any` number. */
 export const MARK_LIMITS: readonly string[];

package/types/engine/markdown-blocks.d.mts

@@ -3,6 +3,10 @@
  * and must not be modified; an `inline` token carries no `children`.
  *
  * @param {unknown} source - Markdown.
+ * @param {object} [options] - Optional block projection.
+ * @param {boolean} [options.footnotes=false] - Include footnote definition containers.
  * @returns {readonly import("markdown-it").Token[]} The block tokens, in order.
  */
-export function blockTokens(source: unknown): readonly import("markdown-it").Token[];
+export function blockTokens(source: unknown, { footnotes }?: {
+    footnotes?: boolean | undefined;
+}): readonly import("markdown-it").Token[];

package/types/engine/office-holders.d.mts

@@ -1,3 +1,36 @@
+/**
+ * A note's identity across its systems: `package-type-shortcode`, lowercased.
+ *
+ * A body's Item and its journal carry one page, and a being names the body by
+ * its `note` Address, so the system is left out.
+ *
+ * @param {{package?: string, type?: string, shortcode?: string}} tuple
+ * @returns {string} The key, or `""` where a part is missing.
+ */
+export function officeBodyKey(tuple: {
+    package?: string;
+    type?: string;
+    shortcode?: string;
+}): string;
+/**
+ * Each body's offices with the living beings that hold them.
+ *
+ * Nothing is authored on the office for this: a being states the post it holds
+ * in its own `data.affiliations.<body>.office`, and this collects, for every
+ * office in a body's `governance.offices`, each being naming it. A being whose
+ * `data.died` is set holds nothing, so a former holder drops out and a vacant
+ * office lists no one. A post the body does not declare is the standing check's
+ * finding and is listed nowhere.
+ *
+ * Offices keep the body's declared order; holders are ordered by name.
+ *
+ * @param {object[]} records - Content-index records; only note records are
+ *   read.
+ * @returns {Map<string, Map<string, object[]>>} Body identity
+ *   (`package-type-shortcode`) → office → the holding beings' records, for every
+ *   body with at least one held office.
+ */
+export function officeHolders(records: object[]): Map<string, Map<string, object[]>>;
 /**
  * Validate one affiliation's office roster against dated beings in the corpus.
  * @param {object} note

package/types/engine/page-breaks.d.mts

@@ -22,6 +22,14 @@ export function scanPageBreaks(source: string): {
  * @returns {string} Markdown without valid page-break lines.
  */
 export function omitPageBreaks(source: string): string;
+/**
+ * Preserve refused markers as literal Markdown before the book slices blocks.
+ * A slice must not make a marker eligible by discarding its original neighbour.
+ * Findings are collected from the original source before this rewrite.
+ * @param {string} source - Complete Markdown body, before splitting containers.
+ * @returns {string} Markdown with invalid markers escaped for literal rendering.
+ */
+export function escapeInvalidPageBreaks(source: string): string;
 /**
  * Produce the book's page-break token, leaving ordinary thematic breaks alone.
  * @param {import("markdown-it")} md - The book parser.

package/types/engine/place-kinds.d.mts

@@ -0,0 +1,18 @@
+/**
+ * Check a district's parent and a route's journeys.
+ *
+ * A district naming no parent is reported at its `subType`; one whose parents
+ * all resolve and none is a settlement or a region is reported at `parents`.
+ * A parent that does not resolve is the Address check's finding, so a district
+ * whose only parents are unresolved earns nothing more here. A route stating no
+ * `data.routes` entry is reported at its `subType`.
+ *
+ * @param {object} note - The note: `file`, `raw` and parsed `fm`.
+ * @param {{index?: object}} [options] - The lint's options.
+ * @returns {object[]} Located findings.
+ */
+export function checkPlaceKind(note: object, { index }?: {
+    index?: object;
+}): object[];
+/** The place kinds a district may stand within. */
+export const DISTRICT_PARENT_KINDS: readonly string[];

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

@@ -1,164 +1,31 @@
 /**
- * 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.
+ * Check indexed rows, locating each finding in its original YAML.
+ * @param {object} note - Indexed note and original locator text.
+ * @param {object} [opts] - Captured context.
+ * @param {object} [opts.index] - Complete local and dependency reference index.
+ * @returns {object[]} Located 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 listed forms, 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[]>;
-};
+ * Fail every publishing surface before it writes invalid settlement output.
+ * @param {object[]} records - Indexed records, including documentation projections.
+ * @param {object} opts - Captured context.
+ * @param {(record: object) => string} opts.fileOf - Source filename for a record.
+ * @param {Map<string,object>} [opts.foreignIndex] - Dependency reference targets.
+ * @param {(file: string) => string|undefined} [opts.rawOf] - Captured locator text.
+ * @returns {void}
+ */
+export function assertSettlementRecords(records: object[], { fileOf, foreignIndex, rawOf }?: {
+    fileOf: (record: object) => string;
+    foreignIndex?: Map<string, object> | undefined;
+    rawOf?: ((file: string) => string | undefined) | undefined;
+}): void;
+/**
+ * Render rows once as shared Markdown; all surfaces consume the same table.
+ * @param {object} record - Indexed region.
+ * @returns {string} Generated table and its closing sentence.
+ */
+export function settlementMarkdown(record: object): string;
+export { SETTLEMENTS_HEADING, SETTLEMENT_COLUMNS, SETTLEMENT_ROW_FIELDS, SETTLEMENTS_FIELD, SETTLEMENT_TABLE_RULES } from "./settlement-terms.mjs";

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

@@ -0,0 +1,53 @@
+/** Dependency-free settlement row declarations. @module */
+/** The generated heading. */
+export const SETTLEMENTS_HEADING: "Settlements";
+/** Rendered columns, in their fixed order; Held by and For appear when a row states them. */
+export const SETTLEMENT_COLUMNS: readonly (Readonly<{
+    name: "Name";
+    required: true;
+}> | Readonly<{
+    name: "Market";
+    required: true;
+}> | Readonly<{
+    name: "People";
+    required: true;
+}> | Readonly<{
+    name: "Held by";
+    required: false;
+}> | Readonly<{
+    name: "For";
+    required: false;
+}>)[];
+/** The closed row fields; existing subjects use native Addresses. */
+export const SETTLEMENT_ROW_FIELDS: readonly Readonly<unknown>[];
+/** The place vocabulary's single settlement declaration. */
+export const SETTLEMENTS_FIELD: Readonly<{
+    name: "settlements";
+    kind: "map";
+    shape: "{ rows, tail }";
+    fields: readonly ({
+        name: string;
+        kind: string;
+        required: boolean;
+        shape: string;
+        entries: {
+            kind: string;
+            shape: string;
+            fields: readonly Readonly<unknown>[];
+        };
+        describe: string;
+    } | {
+        name: string;
+        kind: string;
+        required: boolean;
+        shape: string;
+        describe: string;
+        entries?: undefined;
+    })[];
+    describe: "A region's settlement rows and the sentence stating what they leave out; the table is generated from this declaration.";
+}>;
+/** Every semantic finding, named once for the reference and its guards. */
+export const SETTLEMENT_TABLE_RULES: readonly Readonly<{
+    name: string;
+    describe: string;
+}>[];

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

@@ -21,6 +21,23 @@ export function findSqlBlocks(markdown: string): Array<{
     layout: string;
     block: string;
 }>;
+/**
+ * Where a query reads the `file` block of the index record: `file.path`,
+ * `file.folder` or `file.name`, bare or qualified by a relation or its alias.
+ * A note is selected by property, tag or address, so a query that reaches for
+ * the file it was written in is refused. A field of a note's own data that is
+ * named `file` is not the block and is left alone.
+ *
+ * @param {string} sql - One fence's query.
+ * @returns {{line: number, column: number, text: string}|undefined} The first
+ *   reference, its 0-based line within the query and 1-based column, or
+ *   nothing where the query makes none.
+ */
+export function findFileReference(sql: string): {
+    line: number;
+    column: number;
+    text: string;
+} | undefined;
 /**
  * Open a DuckDB view over the content index.
  *
@@ -205,25 +222,35 @@ export function prepareInlineSqlExpressions(db: any, sources: any): Promise<Map<
  * @param {Map<string, Map<string, string>>} [opts.derived] - The derived
  *   lists, from an earlier call over the same records, which are not derived
  *   again.
+ * @param {Map<string,{raw?:string}>} [opts.parsed] - Captured source locators.
  * @param {object[]} [opts.all=records] - Complete records for lexical lineage
  *   traversal through providers outside the surface's audience.
  * @returns {Promise<{sections: Map<string, string>, views: Set<string>,
  *   derived: Map<string, Map<string, string>>,
- *   lexical: Map<string, import("./lexical-sections.mjs").LexicalSection[]>}>} Note file to its sections,
+ *   lexical: Map<string, import("./lexical-sections.mjs").LexicalSection[]>,
+ *   declared: Map<string, Array<{slug:string,heading:string,markdown:string}>>}>} Note file to its sections,
  *   joined in order; the files whose sections hold an event view's fence; and
  *   the derived lists alone.
  */
-export function generatedSectionsFor(db: object | undefined, records: object[], contentBase: string, { only, foreignIndex, config, derived: given, all }?: {
+export function generatedSectionsFor(db: object | undefined, records: object[], contentBase: string, { only, foreignIndex, config, derived: given, all, parsed }?: {
     only?: string | undefined;
     foreignIndex?: Map<string, object> | undefined;
     config?: object | undefined;
     derived?: Map<string, Map<string, string>> | undefined;
+    parsed?: Map<string, {
+        raw?: string;
+    }> | undefined;
     all?: object[] | undefined;
 }): Promise<{
     sections: Map<string, string>;
     views: Set<string>;
     derived: Map<string, Map<string, string>>;
     lexical: Map<string, import("./lexical-sections.mjs").LexicalSection[]>;
+    declared: Map<string, Array<{
+        slug: string;
+        heading: string;
+        markdown: string;
+    }>>;
 }>;
 /**
  * Join each note's generated sections to its body among the sources a
@@ -262,13 +289,18 @@ export function joinGeneratedSections(generated: {
  * empty set carrying them.
  *
  * @param {Map<string, object[]>} prepared - From {@link prepareSqlTables}.
- * @param {{sections: Map<string, string>, lexical?: Map<string, import("./lexical-sections.mjs").LexicalSection[]>}} generated - From
+ * @param {{sections: Map<string, string>, lexical?: Map<string, import("./lexical-sections.mjs").LexicalSection[]>, declared?: Map<string, Array<{slug:string,heading:string,markdown:string}>>}} generated - From
  *   {@link generatedSectionsFor}.
  * @returns {void}
  */
 export function attachGeneratedSections(prepared: Map<string, object[]>, generated: {
     sections: Map<string, string>;
     lexical?: Map<string, import("./lexical-sections.mjs").LexicalSection[]>;
+    declared?: Map<string, Array<{
+        slug: string;
+        heading: string;
+        markdown: string;
+    }>>;
 }): void;
 /**
  * Each declared dependency's cached index, as {@link openNotesDatabase} attaches

package/types/engine/standing-terms.d.mts

@@ -20,8 +20,9 @@ export const STANDING_BODY_TYPES: readonly string[];
  * The keys one standing carries, as inner-key declarations.
  *
  * `rank` is the level on the body's own `governance.ranks` ladder, and every
- * membership states one. `office` is a key of its `governance.offices` map, and
- * is stated only where the being holds a post. `societies` names the societies
+ * membership states one. `office` is a key of its `governance.offices` map, or
+ * a list of them where the being holds several posts in that body, and is
+ * stated only where the being holds a post. `societies` names the societies
  * the membership is held in, as a list because a membership can span several.
  *
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}

package/types/engine/standings.d.mts

@@ -98,12 +98,24 @@ export function standingsDigest(fm: object): {
     ranks?: Record<string, string>;
     offices?: Record<string, string>;
 } | undefined;
+/**
+ * The posts a standing holds, trimmed, in the order written.
+ *
+ * `office` is one post or a list of them, and every reader — the line on the
+ * being's page, the SoHL item, the derived holders of an office — wants the
+ * same list from both.
+ *
+ * @param {object} [standing] - `{rank, office}`, either or both absent.
+ * @returns {string[]} The posts, blank and non-text entries left out.
+ */
+export function standingOffices(standing?: object): string[];
 /**
  * What a standing says before the body that confers it — `War Chief, Hárár
  * (5), of ` — or `""` where no standing is held.
  *
  * The office leads, because it is the more particular of the two: a reader
- * meeting "War Chief" has been told the rung as well. The rung follows as its
+ * meeting "War Chief" has been told the rung as well. Several posts in one
+ * body lead in the order written, `Treasurer, Chancellor, …`. The rung follows as its
  * title with its level in parentheses, read from the body's own ladder; where
  * the ladder names no rung at that level, or none is available, it reads as
  * `Rank 5` and the number is not repeated. The body closes the phrase, which is
@@ -131,7 +143,7 @@ export function standingLead(standing: object, digest?: {
  * 3. the entry states a standing at all — what a stated standing holds is the
  *    inner-key check's, read from {@link STANDING_FIELDS};
  * 4. a `rank` is a level the named body's `governance.ranks` declares;
- * 5. an `office` is a key of that body's `governance.offices`.
+ * 5. each post an `office` names is a key of that body's `governance.offices`.
  *
  * Both of the last two are read from the named body's own frontmatter as the
  * lint runs, so a rung or a post that does not exist fails on every being pointing

package/types/engine/unique-items.d.mts

@@ -0,0 +1,12 @@
+/**
+ * Report a unique item whose note links no place or being.
+ *
+ * @param {object} note - The note: `file`, `raw`, `body` and parsed `fm`.
+ * @param {{index?: object}} [options] - The lint's options.
+ * @returns {object[]} The finding, located at `unique`, or none.
+ */
+export function checkUniqueItem(note: object, { index }?: {
+    index?: object;
+}): object[];
+/** The note types a unique item's links must reach at least one of. */
+export const UNIQUE_ITEM_LINK_TYPES: readonly string[];