@heroiclands/package-build 23.7.1 → 23.9.0

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

@@ -1,3 +1,11 @@
+/**
+ * Render a dictionary entry's marked headword as an inline native heading in
+ * Foundry. Its paragraph becomes a div, so the heading has a valid container.
+ * The shared Markdown keeps its span and its containing journal page.
+ *
+ * @param {import("markdown-it")} md - The Foundry Markdown parser.
+ */
+export function dictionaryEntryPlugin(md: typeof import("markdown-it")): void;
 /**
  * @typedef {object} LayoutOptions
  * @property {(ref: object) => boolean} [linkable] - Whether an Address can be
@@ -6,10 +14,16 @@
  * @property {object} [addressContext] - Address resolution context.
  * @property {(address: string) => string|undefined} [labelOf] - A note's
  *   `name.full`, by its Address.
- * @property {boolean|"only"} [showKey=true] - Whether the key is printed;
- *   `"only"` prints the key and nothing else.
+ * @property {boolean|"only"} [showKey=true] - Whether the key and dictionary
+ *   head tables are printed; `"only"` prints the key and nothing else.
  * @property {string} [pageLanguage] - The language of the page the fence is
  *   on, which no entry is tagged with.
+ * @property {string} [pageOwner] - The containing page's canonical note Address;
+ *   a sense attributed only to its own row's owner omits that label on this page.
+ * @property {boolean} [entryAnchors=true] - Whether dictionary headwords carry
+ *   their canonical targets; custom SQL views leave those to the automatic list.
+ * @property {object} [verbs] - The owning language's stated pattern, including
+ *   when its automatic dictionary has no eligible word entries.
  */
 /**
  * Render a result of words as a dictionary.
@@ -44,6 +58,8 @@ export const LAYOUT_REQUIRED_COLUMNS: Readonly<{
 }>;
 /** The mark a common entry opens with. */
 export const COMMON_MARK: "\u2022";
+/** The word-entry span class whose Foundry rendering is a native TOC heading. */
+export const DICTIONARY_ENTRY_CLASS: "dictionary-entry";
 export type LayoutOptions = {
     /**
      * - Whether an Address can be
@@ -64,8 +80,8 @@ export type LayoutOptions = {
      */
     labelOf?: ((address: string) => string | undefined) | undefined;
     /**
-     * - Whether the key is printed;
-     * `"only"` prints the key and nothing else.
+     * - Whether the key and dictionary
+     * head tables are printed; `"only"` prints the key and nothing else.
      */
     showKey?: boolean | "only" | undefined;
     /**
@@ -73,4 +89,19 @@ export type LayoutOptions = {
      * on, which no entry is tagged with.
      */
     pageLanguage?: string | undefined;
+    /**
+     * - The containing page's canonical note Address;
+     * a sense attributed only to its own row's owner omits that label on this page.
+     */
+    pageOwner?: string | undefined;
+    /**
+     * - Whether dictionary headwords carry
+     * their canonical targets; custom SQL views leave those to the automatic list.
+     */
+    entryAnchors?: boolean | undefined;
+    /**
+     * - The owning language's stated pattern, including
+     * when its automatic dictionary has no eligible word entries.
+     */
+    verbs?: object | undefined;
 };

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

@@ -1,3 +1,12 @@
+/**
+ * The stable prose anchor of a word in one language's dictionary. The exact
+ * language and NFC form identify it, including case and accents.
+ *
+ * @param {string} language - The language's canonical note Address.
+ * @param {string} name - The dictionary headword.
+ * @returns {string} The anchor slug.
+ */
+export function dictionaryEntryAnchor(language: string, name: string): string;
 /**
  * The heading letter of a sort key: its first letter or digit, accents taken
  * off and apostrophes skipped, in capitals; `#` where it has none.

package/types/engine/foundry-entries.d.mts

@@ -1,5 +1,7 @@
 /**
- * Every page of a note's journal, as `anchorName → whole UUID`.
+ * Every anchor of a note's journal, as `anchorName → Foundry target`.
+ * A dictionary word's native heading carries its fragment after the
+ * containing page's UUID.
  *
  * Whole, not a fragment appended to the entry's UUID: nothing owns a page
  * address, so a complete link restates no fact, and it keeps the page-id hash

package/types/engine/heading-attributes.d.mts

@@ -46,8 +46,8 @@ export function opensPage({ level, id }: {
 /**
  * Every heading in a body, with what its attribute block declares.
  *
- * Fenced code is skipped: `#` opens a comment in most of what gets fenced, and
- * an example heading in a document is not a heading of it.
+ * Code and raw HTML blocks are skipped: an example heading in a document is
+ * not a heading of it, including an example in an HTML comment.
  *
  * @param {string} source - A note's markdown body.
  * @param {number} [bodyLine=1] - The 1-based file line the body starts on, so a

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?: {
@@ -361,11 +364,14 @@ export function defaultStats(): object;
  *   omitted.
  * @param {readonly object[]} [opts.records] - The corpus, derived once per
  *   compile and handed in. Required: see {@link assertSuppliedCorpus}.
+ * @param {Map<string, object[]>} [opts.sqlTables] - Prepared directives,
+ *   including the anchors and Foundry page maps of their expanded bodies.
  * @returns {{byShortcode: Map, types: Set}} From `buildWikilinkIndex`.
  */
-export function buildContentLinkIndex(contentBase: string, router?: object, { config, records }?: {
+export function buildContentLinkIndex(contentBase: string, router?: object, { config, records, sqlTables }?: {
     config?: object | undefined;
     records?: readonly object[] | undefined;
+    sqlTables?: Map<string, object[]> | undefined;
 }): {
     byShortcode: Map<any, any>;
     types: Set<any>;

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

@@ -319,6 +319,13 @@ export const NEAR_NAME_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[]
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const NAMING_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The six present persons of the one optional regular verb pattern, in
+ * presentation order. Empty endings leave the citation form unchanged.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const VERB_PERSON_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

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

@@ -0,0 +1,95 @@
+/**
+ * Whether frontmatter supplies an automatic lexical section, including on a
+ * note with no authored prose. Such a note has content and is not a stub.
+ *
+ * @param {object|null|undefined} frontmatter - A note or its index record.
+ * @returns {boolean} Whether its own nonempty words or glossary qualify.
+ */
+export function hasLexicalEntries(frontmatter: object | null | undefined): boolean;
+/**
+ * One automatic section, whose rows are rendered at its containing heading's
+ * level when inserted.
+ *
+ * @typedef {object} LexicalSection
+ * @property {string} slug - The canonical section anchor and layout name.
+ * @property {string} heading - The heading used when none is authored.
+ * @property {readonly string[]} aliases - Authored heading anchors to reuse.
+ * @property {{columns: string[], rows: object[]}} result - The selected rows.
+ * @property {import("./dictionary-layout.mjs").LayoutOptions} options - Labels,
+ *   linkability and the page's language, shared by every surface.
+ */
+/**
+ * Automatic lexical sections by owning note's canonical Address. Only
+ * nonempty own `words` or `glossary` arrays qualify. A glossary selects only
+ * explicitly declared owner entries, including a rank only when named there.
+ *
+ * @param {object[]} records - The audience's visible index records.
+ * @param {object[]} [all=records] - Complete records for lineage traversal.
+ * @returns {Map<string, LexicalSection[]>} Sections by owning Address.
+ */
+export function lexicalSectionsFor(records: object[], all?: object[]): Map<string, LexicalSection[]>;
+/**
+ * Insert lists at the end of their authored anchored sections, or append a
+ * new H1 section when no heading names one. Source lines after an insertion
+ * retain their original positions; inserted lines point to their heading.
+ *
+ * @param {string} markdown - The body with authored directives expanded.
+ * @param {LexicalSection[]} [sections=[]] - From {@link lexicalSectionsFor}.
+ * @param {{authored?: string, lineMap?: object[], generatedFrom?: number}} [context] -
+ *   The original authored body, source mappings and the start of appended
+ *   nonlexical generated sections. Without `authored`, `markdown` is the source.
+ * @returns {{markdown: string, lineMap: object[], generatedFrom?: number}}
+ */
+export function insertLexicalSections(markdown: string, sections?: LexicalSection[], { authored, lineMap, generatedFrom }?: {
+    authored?: string;
+    lineMap?: object[];
+    generatedFrom?: number;
+}): {
+    markdown: string;
+    lineMap: object[];
+    generatedFrom?: number;
+};
+/** The automatic lexical sections and the authored anchors each may reuse. */
+export const LEXICAL_SECTIONS: readonly Readonly<{
+    aliases: readonly string[];
+    types: readonly Readonly<{
+        type: string;
+        subType: string;
+    } | {
+        type: string;
+        subType?: undefined;
+    }>[];
+    slug: string;
+    heading: string;
+    dataKey: string;
+}>[];
+/**
+ * One automatic section, whose rows are rendered at its containing heading's
+ * level when inserted.
+ */
+export type LexicalSection = {
+    /**
+     * - The canonical section anchor and layout name.
+     */
+    slug: string;
+    /**
+     * - The heading used when none is authored.
+     */
+    heading: string;
+    /**
+     * - Authored heading anchors to reuse.
+     */
+    aliases: readonly string[];
+    /**
+     * - The selected rows.
+     */
+    result: {
+        columns: string[];
+        rows: object[];
+    };
+    /**
+     * - Labels,
+     * linkability and the page's language, shared by every surface.
+     */
+    options: import("./dictionary-layout.mjs").LayoutOptions;
+};

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-state.d.mts

@@ -43,7 +43,8 @@ export function isStubbableType(type: string | null | undefined, vocabulary?: Re
     stubbable?: boolean;
 }>>): boolean;
 /**
- * Whether a note is a stub: an empty body on a type an empty body suppresses.
+ * Whether a note is a stub: an empty body on a type an empty body suppresses,
+ * without an automatic dictionary or glossary supplied by its frontmatter.
  *
  * The one place the two halves are put together, so the index, the lint and the
  * guard cannot answer it differently.

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/site-build.d.mts

@@ -109,11 +109,14 @@ export function writeHomepages(outRoot: string, pages: readonly object[], config
  * @param {object} options
  * @param {object} options.config - The resolved build configuration.
  * @param {object[]} options.records - Content-index records.
+ * @param {Map<string, object[]>} [options.sqlTables] - Prepared directives,
+ *   whose emitted anchors belong to the pages they expand in.
  * @returns {object} The gate results and, when they pass, the built index.
  */
-export function siteGates(pages: object[], findings: object, { config, records }: {
+export function siteGates(pages: object[], findings: object, { config, records, sqlTables }: {
     config: object;
     records: object[];
+    sqlTables?: Map<string, object[]> | undefined;
 }): object;
 /**
  * The gate result of a build that ran none of them.

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;
@@ -188,20 +191,25 @@ 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 {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>>}>} Note file to its sections,
+ *   derived: Map<string, Map<string, string>>,
+ *   lexical: Map<string, import("./lexical-sections.mjs").LexicalSection[]>}>} 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 }?: {
+export function generatedSectionsFor(db: object | undefined, records: object[], contentBase: string, { only, foreignIndex, config, derived: given, all }?: {
     only?: string | undefined;
     foreignIndex?: Map<string, object> | undefined;
     config?: object | undefined;
     derived?: Map<string, Map<string, 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[]>;
 }>;
 /**
  * Join each note's generated sections to its body among the sources a
@@ -216,7 +224,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 +237,7 @@ export function joinGeneratedSections(generated: {
     source: string;
     markdown: string;
     frontmatter?: object;
+    authoredSqlBlocks?: number;
 }>, parsed?: Map<string, {
     body: string;
     frontmatter: object | null;
@@ -239,12 +248,13 @@ export function joinGeneratedSections(generated: {
  * empty set carrying them.
  *
  * @param {Map<string, object[]>} prepared - From {@link prepareSqlTables}.
- * @param {{sections: Map<string, string>}} generated - From
+ * @param {{sections: Map<string, string>, lexical?: Map<string, import("./lexical-sections.mjs").LexicalSection[]>}} 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[]>;
 }): void;
 /**
  * Each declared dependency's cached index, as {@link openNotesDatabase} attaches
@@ -309,6 +319,30 @@ export function prepareTreeSqlTables(contentBase: string, { config, skipDirector
     audience?: "all" | "public" | undefined;
     foreignIndex?: Map<string, object> | undefined;
 }): Promise<Map<string, object[]> | undefined>;
+/**
+ * Prepare authored link-check tables in each source note's audience. Public
+ * sources share one public database; GM sources share one complete database.
+ * Complete records remain available for authored-link checks.
+ *
+ * @param {string} contentBase - Root of the content tree.
+ * @param {object} [opts]
+ * @param {object} [opts.config] - Resolved configuration.
+ * @param {readonly string[]} [opts.skipDirectories] - The walk's scope.
+ * @param {object[]} [opts.records] - Complete index records already derived.
+ * @param {Map<string, {body: string, frontmatter: object|null}>} [opts.parsed] - Parsed notes.
+ * @param {Map<string, object>} [opts.foreignIndex] - Published dependency indexes.
+ * @returns {Promise<Map<string, object[]>|undefined>} Prepared tables by source.
+ */
+export function prepareLinkSqlTables(contentBase: string, { config, skipDirectories, records, parsed, foreignIndex }?: {
+    config?: object | undefined;
+    skipDirectories?: readonly string[] | undefined;
+    records?: object[] | undefined;
+    parsed?: Map<string, {
+        body: string;
+        frontmatter: object | null;
+    }> | undefined;
+    foreignIndex?: Map<string, object> | undefined;
+}): Promise<Map<string, object[]> | undefined>;
 /**
  * Aliases the renderer reads rather than printing.
  *

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

@@ -1,13 +1,15 @@
 /**
- * A lookup from a built piece to its gloss, over the words (stems included)
- * and affixes of one or more languages.
+ * A lookup from a built piece to its gloss, over the words (stems included),
+ * affixes and elements of one or more languages.
  *
- * Languages are given nearest first: a language's own words, then its own
- * affixes, then the next language's, so a daughter's entry wins over its
- * parent's. A piece matches an entry written exactly as it is, and failing
- * that one written with the same letters and different joining hyphens, so
+ * For each spelling, languages are given nearest first: a language's own
+ * words, then its affixes and elements, then the next language's. A piece
+ * matches an exact spelling across the lineage first, and failing that one
+ * written with the same letters and different joining hyphens, so
  * `wulf-` finds the word `wulf`. Within a language a word's own gloss wins over
- * an affix's.
+ * an affix's, and both precede an element's sense. Elements also match their
+ * declared variants; affixes also match their front-vowel forms. Spelling,
+ * including case and accents, is preserved.
  *
  * @param {...object} datas - Each language note's `data`, nearest first.
  * @returns {(piece: string) => string|null} The gloss, or `null` where none resolves.