@heroiclands/package-build 23.7.0 → 23.8.0

package/types/engine/diagnostics.d.mts

@@ -150,12 +150,14 @@ export function positionInFrontmatter(raw: string, key: string, value?: string,
  *   {@link positionInFrontmatter}.
  * @param {boolean} [options.topLevel=false] - Require the key at column 1, so
  *   an identically named nested key cannot answer for it.
+ * @param {string} [options.raw] - Source text already read by the caller.
  * @returns {{line?: number, column?: number}|undefined} Spreadable position
  *   fields, dropped rather than guessed when the file cannot be read or the key
  *   cannot be found — as `formatDiagnostic` requires.
  */
-export function locateFrontmatterKey(absPath: string | undefined, key: string, value?: string, { topLevel }?: {
+export function locateFrontmatterKey(absPath: string | undefined, key: string, value?: string, { topLevel, raw }?: {
     topLevel?: boolean | undefined;
+    raw?: string | undefined;
 }): {
     line?: number;
     column?: number;
@@ -195,11 +197,10 @@ export function positionOfLiteral(text: string, needle: string, occurrence?: num
  * first occurrence is routinely not the one the finding is about — which is the
  * one thing the located form exists to prevent.
  *
- * A path resolves the exact node instead. The document is re-parsed here rather
- * than threaded from the loader because the loader returns plain data: `yaml`
- * discards ranges once a document is materialised, and carrying a parallel
- * position tree through configuration resolution would be a second
- * representation of the same file to keep in step.
+ * A path resolves the exact node. The most recently located text retains its
+ * document and line counter, so several findings in one note share a parse.
+ * A different text replaces that entry, including an edited copy of the same
+ * file. The loader returns plain data without source ranges.
  *
  * Every failure — unparseable text, an `.mjs` configuration, a path that
  * resolves to nothing — yields `{}`, so a caller spreads the result and the

package/types/engine/helpers.d.mts

@@ -19,17 +19,18 @@ export function renderFoundryMarkdown(body: string, figures?: Array<{
 /**
  * Parses a markdown file with YAML frontmatter.
  *
- * Returns `{ frontmatter, body, description, bodyLine, bodyColumn }` where
+ * Returns `{ frontmatter, body, description, bodyLine, bodyColumn, raw }` where
  * `body` is the trimmed raw markdown after the frontmatter block, and
- * `description` is `body` rendered to HTML. `bodyLine` / `bodyColumn` are the
+ * `description` is `body` rendered to HTML. The full source is retained as
+ * `raw` for diagnostic locations. `bodyLine` / `bodyColumn` are the
  * 1-based **file** position of the body's first character, which is what turns
  * an offset within `body` into a position a diagnostic can name — see
  * {@link positionInBody}. If the file has no frontmatter block, returns
- * `{ frontmatter: null, body: "", description: "" }` with a warn log, and no
+ * `{ frontmatter: null, body: "", description: "", raw }` and no
  * position: there is no body to have one.
  * @param {string} filePath - Markdown file to read.
  * @param {{addressContext?: object}} [opts] - Address defaults for decoded fields.
- * @returns {{frontmatter: object|null, body: string, description: string,
+ * @returns {{frontmatter: object|null, body: string, description: string, raw: string,
  *   bodyLine?: number, bodyColumn?: number, parseError?: {message: string,
  *   line?: number, column?: number}}} Parsed note and body position.
  */
@@ -39,6 +40,7 @@ export function parseMarkdownFile(filePath: string, { addressContext }?: {
     frontmatter: object | null;
     body: string;
     description: string;
+    raw: string;
     bodyLine?: number;
     bodyColumn?: number;
     parseError?: {
@@ -118,6 +120,7 @@ export function walkMarkdownTree(rootDir: string, { skipDirectories, addressCont
     frontmatter: object | null;
     body: string;
     description: string;
+    raw: string;
     bodyLine?: number;
     bodyColumn?: number;
     parseError?: {

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

@@ -63,6 +63,73 @@ export function edgeRows(records: Iterable<Record<string, any>>): object[];
  * @returns {object[]}
  */
 export function clusterRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `cluster_groups` rows: one per `data.sounds.clusters.groups` entry,
+ * `clusters` a list.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function clusterGroupRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `mutations` rows: one per `data.sounds.mutations` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function mutationRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `older` rows: one per `data.older` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function olderRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `negation` rows: one per language stating `data.negation`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function negationRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `name_shapes` rows: one per `data.naming.shapes` entry, each range as
+ * its two bounds.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function nameShapeRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `name_edges` rows: one per `data.naming.edges` entry, `sounds` a list,
+ * `vowel` `false` and `of` `name` where unstated.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function nameEdgeRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `name_draws` rows: one per `data.naming.draws` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function nameDrawRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `held_from` rows: one per `data.naming.heldFrom` entry.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function heldFromRows(records: Iterable<Record<string, any>>): object[];
+/**
+ * The `near_names` rows: one per worked example of `data.naming.nearName`,
+ * each with the language's `min_syllables`.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]}
+ */
+export function nearNameRows(records: Iterable<Record<string, any>>): object[];
 /**
  * The `read_past` rows: one per `data.sounds.readPast` entry.
  *
@@ -72,8 +139,8 @@ export function clusterRows(records: Iterable<Record<string, any>>): object[];
 export function readPastRows(records: Iterable<Record<string, any>>): object[];
 /**
  * The `sound_changes` rows: one per step of each `data.soundChanges` set, with
- * the set's `position`, `name`, `from_language` and `to_language`, and the
- * step's `step_position` within it.
+ * the set's `position`, `name`, `from_language`, `to_language` and `takes`,
+ * and the step's `step_position` within it.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}
@@ -118,7 +185,8 @@ export function finalRows(records: Iterable<Record<string, any>>): object[];
 /**
  * The `syllables` rows: one per language stating `data.sounds.syllables`, a
  * list rule always a list (`any` a list of one), the harmony's sets each a
- * column of its own.
+ * column of its own, its partners a list of `{ vowel, partner }` in the order
+ * stated.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}
@@ -182,6 +250,24 @@ export const LETTER_COLUMNS: readonly string[];
 export const EDGE_COLUMNS: readonly string[];
 /** Every column of the `clusters` relation, in order. */
 export const CLUSTER_COLUMNS: readonly string[];
+/** Every column of the `cluster_groups` relation, in order. */
+export const CLUSTER_GROUP_COLUMNS: readonly string[];
+/** Every column of the `mutations` relation, in order. */
+export const MUTATION_COLUMNS: readonly string[];
+/** Every column of the `older` relation, in order. */
+export const OLDER_COLUMNS: readonly string[];
+/** Every column of the `name_shapes` relation, in order. */
+export const NAME_SHAPE_COLUMNS: readonly string[];
+/** Every column of the `name_edges` relation, in order. */
+export const NAME_EDGE_COLUMNS: readonly string[];
+/** Every column of the `name_draws` relation, in order. */
+export const NAME_DRAW_COLUMNS: readonly string[];
+/** Every column of the `held_from` relation, in order. */
+export const HELD_FROM_COLUMNS: readonly string[];
+/** Every column of the `near_names` relation, in order. */
+export const NEAR_NAME_COLUMNS: readonly string[];
+/** Every column of the `negation` relation, in order: one row per language. */
+export const NEGATION_COLUMNS: readonly string[];
 /** Every column of the `stress` relation, in order. */
 export const STRESS_COLUMNS: readonly string[];
 /** Every column of the `finals` relation, in order. */

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

@@ -2,13 +2,15 @@
  * The keys a language note states beside its words: the register of the names
  * the setting gives in the language's reach, the tags the register uses, the
  * forms it does not write, the notes the register covers, the letters and sound
- * rules, the sound changes, the name elements, the roots and the cognates.
+ * rules, the sound changes, the name elements, the roots, the cognates, the
+ * forms older than the rules and the negative particle.
  *
  * A leaf module, importing nothing: the note vocabulary reads these
  * declarations as it loads, and `language-data.mjs` checks what the values
  * mean. Every closed list here — the edges, element positions, register
- * kinds, stress rules, joins, marks, onsets, harmony sets and calling-name
- * uses — holds the labels the setting's own tables use, one word for each.
+ * kinds, stress rules, joins, marks, onsets, harmony sets, cluster uses and
+ * calling-name uses — holds the labels the setting's own tables use, one word
+ * for each.
  *
  * @module
  */
@@ -48,8 +50,30 @@ export const ANY_SOUND: "any";
  * never begins or ends a name.
  */
 export const ELEMENT_POSITIONS: readonly string[];
-/** What a register name is, where a language sorts its names by kind. */
+/**
+ * What a register name is, where a language sorts its names by kind, and the
+ * kind of name an element builds.
+ */
 export const REGISTER_KINDS: readonly string[];
+/**
+ * The class of name a naming shape or edge holds for: every name, a given or a
+ * clan name, or a name by how it is built — `bound` a stem and an ending,
+ * `compound` elements alone.
+ */
+export const NAME_CLASSES: readonly string[];
+/** The class of name a naming edge holds for where it states none. */
+export const ANY_NAME: "name";
+/**
+ * What a place name takes first from what it is held from: a name-stem, a
+ * god's name, a founder's given name, or one of the listed elements.
+ */
+export const HELD_TAKES: readonly string[];
+/** The `takes` values that are a name a place name shapes. */
+export const HELD_NAMES: readonly string[];
+/** How a name is clipped where a place name takes it. */
+export const HELD_CLIPS: readonly string[];
+/** How often a group of clusters stands inside a word. */
+export const CLUSTER_USES: readonly string[];
 /** Where a language's stress falls. */
 export const STRESS_RULES: readonly string[];
 /** Which sounds meet where two parts of a word join. */
@@ -106,6 +130,13 @@ export const LETTER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const EDGE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.clusters.groups` entry: clusters of one kind,
+ * and how often they stand.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const CLUSTER_GROUP_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The keys of a language's `data.sounds.clusters`.
  *
@@ -172,6 +203,13 @@ export const SKELETON_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const FRAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.sounds.mutations` entry: a sound and what it becomes
+ * where a named mutation holds.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const MUTATION_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The keys of a language's `data.sounds`.
  *
@@ -223,6 +261,64 @@ export const CALLING_CLOSING_FIELDS: readonly import("./data-keys.mjs").InnerKey
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const CALLING_NAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.older` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const OLDER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.negation`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NEGATION_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.naming.shapes` entry: how long a class of name runs.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NAME_SHAPE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.naming.edges` entry: the sounds a name may open or
+ * close on, where a name keeps edges ordinary words do not.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NAME_EDGE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.naming.draws` entry: the element kinds a kind of name
+ * is built from.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NAME_DRAW_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.naming.heldFrom` entry: what a place name takes first
+ * from what the place is held from.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const HELD_FROM_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of one `data.naming.nearName.examples` entry.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NEAR_NAME_EXAMPLE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.naming.nearName`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NEAR_NAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.naming`: the parameters its names keep
+ * beyond the rules its words keep.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const NAMING_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The `data` fields this module declares, in the order the vocabulary lists
  * them. {@link module:engine/language-data.checkLanguageData} checks what the
@@ -261,5 +357,11 @@ export const CALLING_CLOSING_KEYS: readonly string[];
 export const ELEMENT_KEYS: readonly string[];
 /** The keys of {@link ROOT_FIELDS}, in declared order. */
 export const ROOT_KEYS: readonly string[];
+/** The keys of {@link MUTATION_FIELDS}, in declared order. */
+export const MUTATION_KEYS: readonly string[];
+/** The keys of {@link CLUSTER_GROUP_FIELDS}, in declared order. */
+export const CLUSTER_GROUP_KEYS: readonly string[];
+/** The keys of {@link OLDER_FIELDS}, in declared order. */
+export const OLDER_KEYS: readonly string[];
 /** The keys of {@link SCOPE_FIELDS}, in declared order. */
 export const SCOPE_KINDS: readonly string[];

package/types/engine/markdownlint-run.d.mts

@@ -9,8 +9,9 @@
  *   `config`, `ignores`, `gitignore` and `globs`.
  * @param {boolean} [params.fix=false] - Repair what markdownlint can, then
  *   report what remains.
- * @returns {Promise<{results: object[]}>} markdownlint results, each with its
+ * @returns {Promise<{results: object[], markup: object[]}>} markdownlint results, each with its
  *   `fileName` relative to `directory`, ordered by file, line and rule.
+ *   `markup` carries block syntax diagnostics with absolute filenames.
  * @throws {MarkdownConfigError} A configuration file the contract refuses.
  */
 export function runMarkdownlint(params: {
@@ -20,6 +21,7 @@ export function runMarkdownlint(params: {
     fix?: boolean | undefined;
 }): Promise<{
     results: object[];
+    markup: object[];
 }>;
 /** Keys an options file may declare at the repository root. */
 export const ROOT_OPTION_KEYS: readonly string[];

package/types/engine/markup-validation.d.mts

@@ -0,0 +1,14 @@
+/**
+ * Validate authored block syntax with positions in the original file.
+ * Frontmatter is masked so literal YAML values cannot become body markup.
+ * @param {string} source - Complete Markdown source, optionally with frontmatter.
+ * @param {string} file - Diagnostic filename.
+ * @returns {Array<{file: string, line: number, column: number, severity: string, message: string}>} Syntax errors.
+ */
+export function markupFindings(source: string, file: string): Array<{
+    file: string;
+    line: number;
+    column: number;
+    severity: string;
+    message: string;
+}>;

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

@@ -71,12 +71,21 @@ export const STRUCTURED_ADDRESSES: readonly ({
     noteType: string;
     path: (string | string[] | undefined)[];
     shape: string;
+} | {
+    path: string[];
+    shape: string;
+    lenient: boolean;
+    type?: undefined;
+    accepts?: undefined;
+    system?: undefined;
+    noteType?: undefined;
 } | {
     path: string[];
     shape: string;
     type: string;
     accepts: string[];
     system: string;
+    lenient?: undefined;
     noteType?: undefined;
 } | {
     noteType: string;
@@ -84,6 +93,7 @@ export const STRUCTURED_ADDRESSES: readonly ({
     shape: string;
     type: string;
     accepts: string[];
+    lenient?: undefined;
     system?: undefined;
 })[];
 export { AddressEntries, encodeAddresses, cloneAddressState, publishAddresses, readPublishedAddresses, flattenPublishedAddresses } from "./address-values.mjs";

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

@@ -120,11 +120,17 @@ export function noteTypeVocabulary(sources?: ClaimSources): ReadonlySet<string>;
  * @param {object} [opts] - Options.
  * @param {readonly object[]} [opts.records] - The corpus, derived once by the
  *   compile and handed in — required, for the reason above.
+ * @param {Map<string, {body: string, raw: string}>} [opts.parsed] - Already parsed
+ *   notes, keyed by file, for body checks and finding positions.
  * @returns {Array<{file: string, line?: number, column?: number,
  *   severity: "error", message: string, type: string}>} One finding per note.
  */
-export function unclaimedNoteFindings(config?: object, sources?: ClaimSources, { records }?: {
+export function unclaimedNoteFindings(config?: object, sources?: ClaimSources, { records, parsed }?: {
     records?: readonly object[] | undefined;
+    parsed?: Map<string, {
+        body: string;
+        raw: string;
+    }> | undefined;
 }): Array<{
     file: string;
     line?: number;

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

@@ -21,13 +21,15 @@ export function searchableFrontmatter(fm: object | null | undefined, configured?
  * @param {string} [options.absPath] - The note's file on disk, read only on the
  *   failing path to locate the offending line and column. The position rides on
  *   the thrown error as `position`, for a caller that emits a diagnostic.
+ * @param {string} [options.raw] - Source text already read by the caller.
  * @param {string} [options.configured] - The package this build compiles.
  *   Defaults to the configured `contentPackage`.
  * @returns {void}
  * @throws {Error} When the note declares the field.
  */
-export function assertNoDeclaredPackage(fm: object | null | undefined, { file, absPath, configured }?: {
+export function assertNoDeclaredPackage(fm: object | null | undefined, { file, absPath, configured, raw }?: {
     file?: string | undefined;
     absPath?: string | undefined;
+    raw?: string | undefined;
     configured?: string | undefined;
 }): void;

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

@@ -476,6 +476,7 @@ export type DataFieldSpec = {
      */
     check?: ((note: object, opts: {
         index?: object;
+        addressContext?: object;
     }) => object[]) | undefined;
     /**
      * - The

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

@@ -14,10 +14,11 @@
  *   the source page's URL and the target page's.
  * @param {ReadonlyMap<string, RelatedEntry>} entries - Every page of this
  *   site, keyed by URL.
+ * @param {ReadonlyMap<string, RelatedEntry[]>} [deliberate] Authored references, including foreign destinations.
  * @returns {Map<string, Related>} URL → the page's `related` block, both lists
  *   sorted, for every page with at least one entry in either.
  */
-export function relatedPages(edges: Iterable<readonly [string, string]>, entries: ReadonlyMap<string, RelatedEntry>): Map<string, Related>;
+export function relatedPages(edges: Iterable<readonly [string, string]>, entries: ReadonlyMap<string, RelatedEntry>, deliberate?: ReadonlyMap<string, RelatedEntry[]>): Map<string, Related>;
 /**
  * The pages a homepage's body links to, as URLs.
  *
@@ -50,6 +51,10 @@ export type RelatedEntry = {
      * site-root-relative form the page states for itself.
      */
     url: string;
+    /**
+     * Why the author recommends this page.
+     */
+    gloss?: string | undefined;
     /**
      * The note's `type`, which the theme groups by.
      */
@@ -59,6 +64,10 @@ export type RelatedEntry = {
  * The `related` block one page publishes.
  */
 export type Related = {
+    /**
+     * Deliberate references in authored order.
+     */
+    seeAlso?: RelatedEntry[] | undefined;
     /**
      * Pages that link to this one.
      */

package/types/engine/see-also.d.mts

@@ -0,0 +1,55 @@
+/**
+ * Validate note references, refusing unresolved, repeated and self destinations.
+ * @param {object} note - The authored note, including its raw source.
+ * @param {object} [options] - The local and declared dependency context.
+ * @param {object} [options.index] - The local and declared dependency index.
+ * @param {string} [options.index.contentPackage] - The package owning the note.
+ * @param {Set<string>} [options.index.types] - The indexed note types.
+ * @param {Set<string>} [options.index.packages] - The indexed packages.
+ * @param {(key: string) => {url?: string, uuid?: string, file?: string}|undefined}
+ *   [options.index.addressHit] - Resolve a canonical Address to its destination.
+ * @param {import("./address.mjs").AddressDefaults} [options.addressContext]
+ *   - The Address defaults and vocabularies at the authored reference.
+ * @returns {object[]} Findings located at the offending address.
+ */
+export function checkSeeAlso(note: object, { index, addressContext }?: {
+    index?: {
+        contentPackage?: string | undefined;
+        types?: Set<string> | undefined;
+        packages?: Set<string> | undefined;
+        addressHit?: ((key: string) => {
+            url?: string;
+            uuid?: string;
+            file?: string;
+        } | undefined) | undefined;
+    } | undefined;
+    addressContext?: import("./address.mjs").AddressDefaults | undefined;
+}): object[];
+/**
+ * Resolve deliberate references in authored order using the surface's index.
+ * @param {object} fm - The note frontmatter.
+ * @param {(address: unknown) => object|undefined} resolve - The surface's reference resolver.
+ * @returns {object[]} Display names, destinations and optional glosses.
+ */
+export function seeAlsoEntries(fm: object, resolve: (address: unknown) => object | undefined): object[];
+/**
+ * A generated section; an empty list emits nothing.
+ * @param {object[]} entries - Resolved references in authored order.
+ * @param {(entry: object) => string} link - The medium's link markup.
+ * @param {number} [level=2] - Heading level; a journal uses one for a separate page.
+ * @returns {string} Markdown for the section.
+ */
+export function seeAlsoMarkdown(entries: object[], link: (entry: object) => string, level?: number): string;
+/**
+ * A reference rendered as an ordinary Markdown link for the book pipeline.
+ * @param {object} entry - A resolved name and URL.
+ * @returns {string} Markdown.
+ */
+export function seeAlsoWebLink(entry: object): string;
+/**
+ * Deliberate site connections for a set of pages, including dependency pages.
+ * @param {object[]} pages - Pages carrying frontmatter and their published URL.
+ * @param {(address: unknown) => object|undefined} resolve - The site's reference resolver.
+ * @returns {Map<string, import("./related-pages.mjs").RelatedEntry[]>} Entries keyed by source URL.
+ */
+export function seeAlsoPages(pages: object[], resolve: (address: unknown) => object | undefined): Map<string, import("./related-pages.mjs").RelatedEntry[]>;

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

@@ -139,8 +139,9 @@ export function renderSqlTable(result: {
  * its own table and not the whole build's report.
  *
  * @param {object} db - From {@link openNotesDatabase}.
- * @param {Array<{source: string, markdown: string}>} sources - The bodies to
- *   scan.
+ * @param {Array<{source: string, markdown: string, frontmatter?: object, authoredSqlBlocks?: number}>} sources -
+ *   The bodies to scan. `joinGeneratedSections` records the number of authored
+ *   fences; following generated event fences need no stub comparison.
  * @param {object} [opts]
  * @param {(ref: string) => boolean} [opts.linkable] - Passed to
  *   {@link renderSqlTable}.
@@ -163,6 +164,8 @@ export function renderSqlTable(result: {
 export function prepareSqlTables(db: object, sources: Array<{
     source: string;
     markdown: string;
+    frontmatter?: object;
+    authoredSqlBlocks?: number;
 }>, { linkable, records, pageLanguage }?: {
     linkable?: ((ref: string) => boolean) | undefined;
     pageLanguage?: ((source: string, frontmatter?: object) => string | undefined) | undefined;
@@ -216,7 +219,7 @@ export function generatedSectionsFor(db: object | undefined, records: object[],
  *
  * @param {{sections: Map<string, string>, views: Set<string>}} generated -
  *   From {@link generatedSectionsFor}.
- * @param {Array<{source: string, markdown: string, frontmatter?: object}>} sources -
+ * @param {Array<{source: string, markdown: string, frontmatter?: object, authoredSqlBlocks?: number}>} sources -
  *   The bodies to answer, extended in place.
  * @param {Map<string, {body: string, frontmatter: object|null}>} [parsed] -
  *   Notes already parsed, keyed by file; a note absent from it is read.
@@ -229,6 +232,7 @@ export function joinGeneratedSections(generated: {
     source: string;
     markdown: string;
     frontmatter?: object;
+    authoredSqlBlocks?: number;
 }>, parsed?: Map<string, {
     body: string;
     frontmatter: object | null;

package/types/engine/word-rows.d.mts

@@ -78,7 +78,8 @@ export function citationLookup(records: Iterable<Record<string, any>>): (languag
 export function wordRows(records: Iterable<Record<string, any>>, all?: Iterable<Record<string, any>>): object[];
 /**
  * The `affixes` rows of a set of index records: one per `data.affixes` entry
- * of a language note, which is the row's `language`.
+ * of a language note, which is the row's `language`, with `written`, the form
+ * as a table prints it: `∅` for a zero affix, whose `form` is `NULL`.
  *
  * @param {Iterable<Record<string, any>>} records - Index records, every
  *   Address a string, already narrowed to the audience being published to.

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

@@ -45,6 +45,17 @@ export const WORD_DATA_KEYS: readonly string[];
  * one; `coined`, `substrate` and `island` name no form.
  */
 export const WORD_SOURCE_KINDS: readonly string[];
+/**
+ * What an affix makes: a case, a word derived from another, a verb's tense,
+ * aspect, mood or voice, a given name's ending, or a lineage name's ending.
+ */
+export const AFFIX_KINDS: readonly string[];
+/** The affix kind whose ending says who the name is given to. */
+export const NAME_AFFIX_KIND: "name";
+/** How a zero affix is written where a table prints it. */
+export const ZERO_AFFIX: "\u2205";
+/** Who a given name's ending is given to. */
+export const AFFIX_GIVEN: readonly string[];
 /** The source kind that requires `language`. */
 export const BORROWED_SOURCE_KIND: "borrowed";
 /**