@heroiclands/package-build 23.13.0 → 24.0.1

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

@@ -52,6 +52,9 @@ export function scanRuns(source: string, ctx?: RunContext, syntax?: import("./co
  *   rewrite that changes the number of lines.
  * - **The map, if any, is applied first.** Characters Markdown would read are
  *   then backslash-escaped, so they reach every later pass as characters.
+ * - **Emphasis in a face** becomes an `<em>` or a `<strong>` carrying its
+ *   convention's class, or no class where none is stated. The book reads
+ *   only the classed form, so a classless one writes nothing there.
  * - **The construct carries** the language's tag as `lang`, the face's class
  *   (with `script`, and `script-block` on a div) or the generic family's
  *   class. On the site, a face's construct also carries
@@ -90,6 +93,27 @@ export const GENERIC_FONTS: Readonly<{
     serif: "font-serif";
     sans: "font-sans";
 }>;
+/**
+ * One `*`, `_`, `**` or `__` that Markdown reads as opening or closing emphasis.
+ */
+export type Delimiter = {
+    /**
+     * - Its first character's offset.
+     */
+    offset: number;
+    /**
+     * - 1 for `*` or `_`, 2 for `**` or `__`.
+     */
+    length: number;
+    /**
+     * - Which level it opens or closes.
+     */
+    tag: "em" | "strong";
+    /**
+     * - Whether it opens.
+     */
+    open: boolean;
+};
 /**
  * One marked construct, with what rendering it needs beside its {@link Run}.
  */
@@ -145,6 +169,21 @@ export type RunDetail = {
      * - A span's offset of its closing `]`.
      */
     contentEnd: number | undefined;
+    /**
+     * -
+     * The convention its language's note states.
+     */
+    languageEmphasis: import("./script-emphasis.mjs").LanguageEmphasis | undefined;
+    /**
+     * -
+     * What its emphasis is set by: its language's convention, else its face's
+     * script's; `undefined` sets it plain.
+     */
+    conventions: import("./script-emphasis.mjs").Emphasis | undefined;
+    /**
+     * - The emphasis it holds, by absolute offset.
+     */
+    emphasis: Delimiter[];
 };
 /**
  * What a run is checked against.
@@ -181,6 +220,29 @@ export type RunContext = {
      * {@link module :engine/run-words.wordBooksFromRecords}.
      */
     wordBooks?: ReadonlyMap<string, import("./run-words.mjs").WordBook> | undefined;
+    /**
+     * -
+     * The metres the `doc` notes declare, by name.
+     */
+    metres?: ReadonlyMap<string, import("./metre-declaration.mjs").Metre> | undefined;
+    /**
+     * -
+     * What each configured language's verse is counted by, from
+     * {@link module :engine/verse-metre.metreBooksFromRecords}.
+     */
+    metreBooks?: ReadonlyMap<string, import("./verse-metre.mjs").MetreBook> | undefined;
+    /**
+     * -
+     * Each face's emphasis conventions, from the script notes, by
+     * {@link module :engine/script-emphasis.emphasesFromRecords}.
+     */
+    emphases?: ReadonlyMap<string, import("./script-emphasis.mjs").Emphasis> | undefined;
+    /**
+     * -
+     * The convention each configured language's note states, by language name,
+     * from {@link module :engine/script-emphasis.languageEmphasesOf}.
+     */
+    languageEmphases?: ReadonlyMap<string, import("./script-emphasis.mjs").LanguageEmphasis> | undefined;
 };
 /**
  * One span, div or verse fence carrying `lang=`, `font=` or `map=`. Its

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

@@ -13,7 +13,7 @@ export function spanMarkdownPlugin(md: typeof import("markdown-it"), { spoilers,
  * @returns {import("./name-markup.mjs").SpanScan} Actual spans, explicit names and located diagnostics.
  */
 export function scanSpans(source: string): import("./name-markup.mjs").SpanScan;
-/** Emit span tags while leaving their inline content as Markdown for Hugo.
+/** Emit span tags while leaving their inline content as Markdown.
  * @param {string} source - Authored Markdown.
  */
 export function renderSpans(source: string): {

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

@@ -0,0 +1,33 @@
+/**
+ * The rules the Foundry content stylesheet shares with other surfaces, scoped
+ * to a selector.
+ *
+ * @param {string} scope - The selector that replaces the Foundry roots.
+ * @returns {string} The rules.
+ * @throws {Error} When the stylesheet marks no shared rules.
+ */
+export function sharedContentRules(scope: string): string;
+/**
+ * The rules that colour highlighted code, scoped to a selector.
+ *
+ * A rule belongs to the set when one of its selectors names a `hljs-` token
+ * class. The rules are taken from the shared stretches, so the colours, their
+ * custom properties and their `light-dark()` pairs are the stylesheet's own.
+ *
+ * @param {string} scope - The selector that replaces the Foundry roots.
+ * @returns {string} The token rules, one per block.
+ */
+export function highlightRules(scope: string): string;
+/**
+ * The stylesheet a site links for highlighted code.
+ *
+ * A site sets no colour scheme, and the token colours are `light-dark()` pairs
+ * that read the scheme in force, so code is given the dark one its pages are
+ * drawn in.
+ *
+ * @param {string} [scope] - The element the page body sits in.
+ * @returns {string} The stylesheet.
+ */
+export function siteCodeStylesheet(scope?: string): string;
+/** The roots the shipped content stylesheet scopes its rules to. */
+export const CONTENT_ROOTS: ":is(.journal-entry-page, .journal-entry-content, .editor-content, .prosemirror)";

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

@@ -0,0 +1,35 @@
+/**
+ * Markdown-it plugin: write each cartouche placeholder as the inline HTML of
+ * its figure, in whatever paragraph, cell or title it stands.
+ * @param {import("markdown-it")} md - Parser to extend.
+ */
+export function cartoucheFigures(md: typeof import("markdown-it")): void;
+/**
+ * Write each glyph and cartouche span as the HTML that draws its picture. A
+ * cartouche is written as a placeholder that {@link cartoucheFigures} turns
+ * into its figure.
+ *
+ * @param {string} source - Markdown that may contain glyph and cartouche spans.
+ * @param {(src: string) => string} [resolveSrc] - From a sign's authored
+ *   pathname to the address the target serves; omitted, the pathname.
+ * @param {object} [options]
+ * @param {boolean} [options.glyphs] - Write glyph spans; `false` leaves them
+ *   as the source they were written in. Default `true`.
+ * @returns {string} The Markdown with each well-formed sign written as HTML or a placeholder.
+ */
+export function renderSymbolSpans(source: string, resolveSrc?: (src: string) => string, { glyphs }?: {
+    glyphs?: boolean | undefined;
+}): string;
+/**
+ * Every picture the glyphs and cartouches of a body name, for a stage that has
+ * to place the files before a compiler reads them.
+ *
+ * @param {string} body - The note's Markdown.
+ * @returns {Array<{src: string, locate: string}>} The authored pathname of each
+ *   picture and the slug that locates it in the note's text, in document order
+ *   within glyphs and then cartouches.
+ */
+export function symbolImagesIn(body: string): Array<{
+    src: string;
+    locate: string;
+}>;

package/types/engine/core-report.d.mts

@@ -0,0 +1,45 @@
+/**
+ * The core report of a set of index records.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @param {{language?: string}} [options] - A language to report alone, by its
+ *   name, shortcode or reference slug whether or not it states `data.core`.
+ * @returns {{concepts: number, languages: Array<{name: string, language: string, core: boolean, total: number, covered: number, missing: Array<{group: string, count: number, total: number, concepts: Array<{id: string, gloss: string}>}>}>}|{problem: string, about: string}}
+ *   The report, or the problem when there is no concept list or the language
+ *   asked for is none.
+ */
+export function coreReport(records: Iterable<Record<string, any>>, { language }?: {
+    language?: string;
+}): {
+    concepts: number;
+    languages: Array<{
+        name: string;
+        language: string;
+        core: boolean;
+        total: number;
+        covered: number;
+        missing: Array<{
+            group: string;
+            count: number;
+            total: number;
+            concepts: Array<{
+                id: string;
+                gloss: string;
+            }>;
+        }>;
+    }>;
+} | {
+    problem: string;
+    about: string;
+};
+/**
+ * A core report as text: one block per language, its missing concepts under
+ * their groups with counts, each concept's id and gloss tab-separated.
+ *
+ * @param {{concepts: number, languages: Array<object>}} report - A report from {@link coreReport}.
+ * @returns {string} The text, ending in a newline.
+ */
+export function coreReportText(report: {
+    concepts: number;
+    languages: Array<object>;
+}): string;

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

@@ -0,0 +1,53 @@
+/**
+ * Every concept id the index's notes state.
+ *
+ * @param {{notes?: Iterable<object>}|undefined} index - The lint index.
+ * @returns {Set<string>|undefined} The ids, or `undefined` without an index.
+ */
+export function conceptIdsIn(index: {
+    notes?: Iterable<object>;
+} | undefined): Set<string> | undefined;
+/**
+ * Check a `doc` note's `data.concepts`: each id's spelling, an id stated twice,
+ * an id another note states, and a blank `gloss` or `group`.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
+ * @param {{index?: {notes?: Iterable<object>}}} [context] - The lint index.
+ * @returns {object[]} The findings, each at its key.
+ */
+export function checkConceptList(note: {
+    file: string;
+    raw?: string;
+    fm?: Record<string, any>;
+}, { index }?: {
+    index?: {
+        notes?: Iterable<object>;
+    };
+}): object[];
+/**
+ * Check a `skill` note's `data.core`: stated on a language only.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - A `skill` note.
+ * @returns {object[]} The findings.
+ */
+export function checkCoreFlag(note: {
+    file: string;
+    raw?: string;
+    fm?: Record<string, any>;
+}): object[];
+/**
+ * What is wrong with a word's `concept`: an id the list does not declare, and
+ * an id stated twice.
+ *
+ * @param {unknown} value - The word's `concept`: an id, or a list of them.
+ * @param {Set<string>|undefined} known - The ids the index declares, or
+ *   `undefined` where there is no index to check against.
+ * @returns {Array<{entry: number|null, message: string}>} Each problem and the
+ *   list entry it sits at, `null` for a single id.
+ */
+export function conceptProblems(value: unknown, known: Set<string> | undefined): Array<{
+    entry: number | null;
+    message: string;
+}>;
+/** What a concept's `id` is made of. */
+export const CONCEPT_ID: RegExp;

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

@@ -0,0 +1,8 @@
+/**
+ * Group each term of every definition list with its definitions.
+ *
+ * @param {string} html - A page's HTML.
+ * @returns {string} The HTML with a `dictionary` class on each `dl` and a `div`
+ *   around each term and the definitions that follow it.
+ */
+export function groupDictionaryLists(html: string): string;

package/types/engine/field-reference.d.mts

@@ -45,7 +45,7 @@ export function renderItemFieldReference({ title, preamble, generatedBy, config,
  * The one question that decides whether `docs item-fields` writes a note
  * envelope: `assets/content/` walks every file under it for its `type:`, so a
  * generated page filed there needs one to publish at all, while a page filed
- * anywhere else — a repository's own `docs/` — is read by nobody but Hugo's
+ * anywhere else — a repository's own `docs/` — is read by nobody but the
  * `--check` guard and the reader following a link, neither of which wants
  * frontmatter.
  *

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

@@ -82,6 +82,26 @@ export function scanHeadingAttributes(source: string, bodyLine?: number): {
  * @returns {void}
  */
 export function headingAttributesPlugin(md: object): void;
+/**
+ * The id a heading's text gives it on the web: GitHub's form, lower case, each
+ * space or hyphen a hyphen, every character that is not a letter, a digit or
+ * an underscore dropped.
+ *
+ * @param {string} text - The heading's text, without its markup.
+ * @returns {string} The id, or `heading` when nothing is left of the text.
+ */
+export function headingId(text: string): string;
+/**
+ * Give every heading an id, so a page's contents list and a reader's link can
+ * name any section.
+ *
+ * An authored `{#id}` is kept, and every other heading takes {@link headingId}
+ * of its text. A repeated id takes `-1`, `-2` and so on, counted over every id
+ * on the page that came before it.
+ *
+ * @param {import("markdown-it")} md - Markdown parser to extend.
+ */
+export function headingIdsPlugin(md: typeof import("markdown-it")): void;
 /**
  * Parse one line as a heading, and say whether it starts a journal page.
  *

package/types/engine/helpers.d.mts

@@ -432,7 +432,7 @@ export function buildContentLinkIndex(contentBase: string, router?: object, { co
  * @param {number} [ctx.bodyLine] - 1-based file line of the body's first line.
  * @param {number} [ctx.bodyColumn] - 1-based file column of the same character.
  * @param {Array<{line: number, generated: boolean}>} [ctx.lineMap] - Which
- *   authored line each body line came from, from {@link expandNoteTables}.
+ *   authored line each body line came from, from {@link module:engine/content-tables.expandContentTables}.
  * @returns {{markdown: string, unresolved: Array<object>}}
  * @throws {Error} On any link that does not resolve — an unlabelled one, a
  *   target that is not an address, or an address nothing publishes — and on a
@@ -491,15 +491,8 @@ export function expandNoteTables(body: string, { name, bodyLine, sqlTables, page
  * @returns {string} Filename for the folder.
  */
 export function folderFilename(name: string, id: string): string;
-/**
- * The markdown renderer every surface shares.
- *
- * `html: true` is long-standing and load-bearing — notes carry raw blocks — and
- * it is also why {@link module:engine/content-icons} exists rather than an
- * instruction to write `<i class="fa-solid …">` by hand: that would render on
- * the two HTML surfaces and be silently dropped by the third.
- */
-export const md: import("markdown-it").MarkdownIt;
+/** The Foundry renderer's parser, for callers that parse or render a fragment. */
+export const md: typeof import("markdown-it");
 export { slugify } from "./content-slug.mjs";
 export { makeId } from "./ids.mjs";
 export { getFrontmatter, sohlField, folderField, resolveCharges, resolveSkillAptitudes, resolveRelation, requireSubType, parseValueDesc } from "./frontmatter.mjs";

package/types/engine/homepage.d.mts

@@ -120,8 +120,10 @@ export function checkHomepageCount(found: ReadonlyArray<{
  * authored `name.full` wins, because a front page may greet a reader
  * differently from a package browser.
  *
- * Falls back to `contentPackage` last, so a package that has no manifest of its
- * own still yields a titled page rather than a blank heading.
+ * A package with no manifest title — a `documentation` package has no manifest
+ * at all — takes `site.title`, the name its site is known by. It falls back to
+ * `contentPackage` last, so a package that states neither still yields a
+ * titled page rather than a blank heading.
  *
  * @param {object|null|undefined} fm - The note's frontmatter.
  * @param {object} config - The resolved configuration.
@@ -133,20 +135,17 @@ export function homepageTitle(fm: object | null | undefined, config: object): st
  *
  * The note's own, plus the two derived values every emitted page carries: the
  * resolved `title`, and the package the build derived — no note declares one
- * and the theme's breadcrumb partial reads `.Params.package`.
+ * and the theme's breadcrumbs read.
  *
- * **No `url` and no `slug`.** Hugo publishes the `home` kind at `baseURL`,
- * whose path is already where the package is served, so the page has no
- * address to state; a content page states one because its file sits under the
- * mount and its address does not.
+ * **No `url` and no `slug`.** The homepage publishes at the package root, so
+ * the page has no address to state.
  *
- * An authored `aliases` is dropped for the same reason it is on every other
- * page: Hugo reads it as URL redirects, so passing it through would publish a
- * redirect stub at each one.
+ * An authored `aliases` is dropped, as it is on every other page: this build
+ * emits no redirects.
  *
  * `related` is derived like every other page's — what links to the homepage
  * is a fact about the rest of the tree — so an authored value is dropped and
- * the caller's block, where it has one, is written in its place.
+ * the caller's block, where it has one, is set in its place.
  *
  * @param {object} fm - The note's frontmatter.
  * @param {object} options - Options.
@@ -154,7 +153,7 @@ export function homepageTitle(fm: object | null | undefined, config: object): st
  * @param {string} options.title - The resolved title.
  * @param {object} [options.related] - The homepage's backlinks and mentions,
  *   where the site build found either.
- * @returns {object} The frontmatter to write.
+ * @returns {object} The frontmatter.
  */
 export function homepageFrontmatter(fm: object, { contentPackage, title, related }: {
     contentPackage: string;
@@ -217,18 +216,6 @@ export const HOMEPAGE_FIELDS: readonly import("./field-spec.mjs").FieldSpec[];
  * @type {string}
  */
 export const HOMEPAGE_SHORTCODE: string;
-/**
- * The file a homepage is written to, relative to the package's site root.
- *
- * The mount's own `_index.md`: Hugo renders it as the `home` kind, at
- * `baseURL` — which is `/<package>/`, the package's own address. One fixed
- * destination rather than one derived from the note's address, because the
- * homepage's address *is* the package root; the note's `shortcode` names the
- * page in links and decides no file.
- *
- * @type {string}
- */
-export const HOMEPAGE_DESTINATION: string;
 /**
  * The top-level fields a homepage refuses, and what each would decide.
  *

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

@@ -0,0 +1,9 @@
+/**
+ * Minify a page.
+ *
+ * @param {string} html - A complete document.
+ * @returns {string} The same document without comments and with each run of
+ *   white space outside the verbatim elements cut to one character: a newline
+ *   where the run held one, a space otherwise.
+ */
+export function minifyHtml(html: string): string;

package/types/engine/index.d.mts

@@ -61,6 +61,8 @@ export * as packages from "./packages.mjs";
 export * as packagebuildIndex from "./packagebuild-index.mjs";
 export * as siteBuild from "./site-build.mjs";
 export * as sitePreview from "./site-preview.mjs";
+export * as previewIndex from "./preview-index.mjs";
+export * as contentRender from "./content-render.mjs";
 export * as contentLint from "./content-lint.mjs";
 export * as contentCharset from "./content-charset.mjs";
 export * as pathCharset from "./path-charset.mjs";
@@ -71,7 +73,6 @@ export * as contentTaskLists from "./content-tasklists.mjs";
 export * as contentEmbeds from "./content-embeds.mjs";
 export * as pathnames from "./pathnames.mjs";
 export * as contentLinks from "./content-links.mjs";
-export * as webWikilinks from "./web-wikilinks.mjs";
 export * as contentTables from "./content-tables.mjs";
 export * as helpers from "./helpers.mjs";
 export * as itemRegistry from "./item-registry.mjs";

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

@@ -74,8 +74,19 @@ export const HELD_NAMES: readonly string[];
 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[];
+/** The syllable a word of two stresses. */
+export const STRESS_TWO: readonly string[];
+/** The syllable a word of three or more stresses, counted from its end. */
+export const STRESS_LONGER: readonly string[];
+/**
+ * The diacritics that mark a stress the rule would not choose, with the
+ * combining character each is written with.
+ */
+export const STRESS_MARKS: Readonly<{
+    acute: "́";
+    grave: "̀";
+    circumflex: "̂";
+}>;
 /** Which sounds meet where two parts of a word join. */
 export const JOIN_MEETINGS: readonly string[];
 /**
@@ -183,6 +194,12 @@ export const MARK_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const HARMONY_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a language's `data.sounds.stress`.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const STRESS_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The keys of a language's `data.sounds.syllables`: what a syllable may open
  * and close on, and what a word may.
@@ -327,6 +344,11 @@ export const NAMING_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const VERB_PERSON_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The endings `data.grammar.native` writes under a logographic map: the noun
+ * plural, then the six persons of the verb pattern.
+ */
+export const WRITTEN_ENDINGS: readonly string[];
 /**
  * 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/logographic.d.mts

@@ -0,0 +1,45 @@
+/**
+ * Where a word's writing comes from, or why it has none.
+ *
+ * @typedef {{text: string, source: "own"|"parts"}
+ *   | {missing: true, noLexicon?: true}
+ *   | {ambiguous: {form: string, glosses: string[]}}} Writing
+ */
+/**
+ * The text a list of native entries states for a map in a face: the entry for
+ * the face, else the entry for no face.
+ *
+ * @param {unknown} natives - A `native` list as authored.
+ * @param {string} map - The map's name.
+ * @param {string|undefined} font - The face.
+ * @returns {string|undefined} The text.
+ */
+export function nativeText(natives: unknown, map: string, font: string | undefined): string | undefined;
+/**
+ * The writings of a language's words under one logographic map in one face.
+ *
+ * @param {Record<string, any>|undefined} data - The language note's `data`.
+ * @param {string} map - The map's name.
+ * @param {string|undefined} font - The face.
+ * @returns {{word: (word: string) => Writing, entry: (index: number) => Writing}}
+ *   The writing of a run's word, and of the `data.words` entry at an index.
+ */
+export function writingsOf(data: Record<string, any> | undefined, map: string, font: string | undefined): {
+    word: (word: string) => Writing;
+    entry: (index: number) => Writing;
+};
+/**
+ * Where a word's writing comes from, or why it has none.
+ */
+export type Writing = {
+    text: string;
+    source: "own" | "parts";
+} | {
+    missing: true;
+    noLexicon?: true;
+} | {
+    ambiguous: {
+        form: string;
+        glosses: string[];
+    };
+};

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

@@ -65,7 +65,10 @@ export function nativeLookup(lexicon: Lexicon | undefined, map: string, font: st
  * @property {import("./text-maps.mjs").TextMap} map - The map.
  * @property {string|undefined} font - The face, whose own rows come first.
  * @property {((word: string) => string|undefined)|undefined} native - The
- *   language's native forms under the map in the face.
+ *   language's native forms under the map in the face, for a map that spells
+ *   by its rows.
+ * @property {((word: string) => import("./logographic.mjs").Writing)|undefined} writing -
+ *   Each word's writing, for a logographic map.
  */
 /**
  * The one path from a map, a face and a language to what rewrites the text.
@@ -103,6 +106,17 @@ export function fontProblem(map: import("./text-maps.mjs").TextMap, font: string
  * @returns {string} The message.
  */
 export function uncapitalisedMessage(word: string, lower: string, lang: string | undefined, map: string): string;
+/**
+ * What is wrong with a word a logographic map gives no writing.
+ *
+ * @param {string} word - The word as written.
+ * @param {object} unwritten - Why it has none, as
+ *   {@link module:engine/logographic.writingsOf} says.
+ * @param {string|undefined} lang - The run's language.
+ * @param {string} map - The map's name.
+ * @returns {string} The message.
+ */
+export function unwrittenMessage(word: string, unwritten: object, lang: string | undefined, map: string): string;
 /**
  * Map a passage exactly as the build maps a run with the same keys.
  *
@@ -129,10 +143,17 @@ export function transliterate(ctx: object, keys: {
  * each case folded and naming the word it comes from in `from`, so the list
  * is what the mapped-run word check accepts of the lexicon.
  *
+ * Under a logographic map an entry carries `source` in place of `exception`:
+ * `own` for a writing it states, `parts` for one its parts give, and `none`,
+ * with an empty `native`, where it has none. A word whose form a run cannot
+ * write, because the form stands for entries written differently, or a part
+ * does, also carries `ambiguous: true`; its `native` is still its own
+ * writing, the signs a run writes directly for that sense.
+ *
  * @param {object} ctx - The run context.
  * @param {{lang: string, map: string, font?: string, derived?: boolean}} keys -
  *   The language, the map, the face, and whether to list derived forms.
- * @returns {{entries: Array<{form: string, native: string, exception: boolean, class: string|null, gloss: string|null, from?: string}>}|{problem: string, about: string}}
+ * @returns {{entries: Array<{form: string, native: string, exception?: boolean, source?: "own"|"parts"|"none", ambiguous?: true, class: string|null, gloss: string|null, from?: string}>}|{problem: string, about: string}}
  *   The words in `data.words` order, then any derived forms, or the problem.
  */
 export function lexiconEntries(ctx: object, { lang, map, font, derived }: {
@@ -144,7 +165,9 @@ export function lexiconEntries(ctx: object, { lang, map, font, derived }: {
     entries: Array<{
         form: string;
         native: string;
-        exception: boolean;
+        exception?: boolean;
+        source?: "own" | "parts" | "none";
+        ambiguous?: true;
         class: string | null;
         gloss: string | null;
         from?: string;
@@ -172,10 +195,16 @@ export function checkMapFonts(note: {
     maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>;
 }): object[];
 /**
- * Check a language note's native forms against the maps and faces: an unknown
- * map, a face the map is not for, a second form for one map and face, a form
- * that states what the rows already give, and a code point a face it applies
- * in does not draw. The shape of each entry is the data-key check's.
+ * Check a language note's native forms against the maps and faces: a word's
+ * `native`, an affix's, and the endings' in `data.grammar.native`. Each is
+ * checked for an unknown map, a face the map is not for, a second form for one
+ * map and face (and one ending), and a code point a face it applies in does
+ * not draw. A word's form under a map that spells by its rows is also checked
+ * for stating what the rows already give; under a logographic map the rows
+ * spell no word, so that check does not apply. An affix's and an ending's
+ * writings mean something only under a logographic map, and an ending of a
+ * person is written only where `data.grammar.verbs` states `persons`. The
+ * shape of each entry is the data-key check's.
  *
  * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
  * @param {{faces?: ReadonlyMap<string, import("./script-fonts.mjs").Face>, maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap>}} ctx -
@@ -266,6 +295,11 @@ export type Lexicon = {
         form: string;
         from: LexiconWord;
     }>;
+    /**
+     * - The language note's `data`, which a
+     * logographic map writes words from.
+     */
+    data: Record<string, any>;
 };
 /**
  * What a run, a passage or a listing is mapped by.
@@ -281,7 +315,13 @@ export type Mapping = {
     font: string | undefined;
     /**
      * - The
-     * language's native forms under the map in the face.
+     * language's native forms under the map in the face, for a map that spells
+     * by its rows.
      */
     native: ((word: string) => string | undefined) | undefined;
+    /**
+     * -
+     * Each word's writing, for a logographic map.
+     */
+    writing: ((word: string) => import("./logographic.mjs").Writing) | undefined;
 };

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

@@ -1,3 +1,11 @@
+/**
+ * A list of places — `parents`, a being's `homes`, a scenario's `locations` —
+ * as their shortcodes.
+ *
+ * @param {unknown} value - The authored value, a list or a lone entry.
+ * @returns {string[]} Shortcodes, lower case, empties dropped.
+ */
+export function placeShortcodes(value: unknown): string[];
 /**
  * Read this package's places and polities out of its index records.
  *