@heroiclands/package-build 25.0.0 → 25.1.0

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

@@ -1,37 +1,43 @@
 /**
- * The context a resolved configuration gives, and the maps an index holds.
+ * The context a resolved configuration gives, and the encodings an index holds.
  *
- * @param {{languages?: object, rootDir?: string}|undefined} config - The
+ * @param {{languages?: object, rootDir?: string, contentPackage?:string, paths?:{content?:string}}|undefined} config - The
  *   resolved configuration.
  * @param {Iterable<Record<string, any>>} [records] - The content index's
- *   records, whose mapping notes give the maps. Without them no map is known.
+ *   records, whose language notes supply lexical writings and script choices.
  * @returns {RunContext} Its languages, the faces installed where it sits, and
- *   the maps. A fonts package that cannot be read gives no faces; a run naming
+ *   the encodings. A fonts package that cannot be read gives no faces; a run naming
  *   one is reported.
  */
 export function runContext(config: {
     languages?: object;
     rootDir?: string;
+    contentPackage?: string;
+    paths?: {
+        content?: string;
+    };
 } | undefined, records?: Iterable<Record<string, any>>): RunContext;
 /**
  * Find the spans, divs and verse fences marked with `lang=`, `font=` or
- * `map=`, and every fault in their markup and their text.
+ * `enc=`, and every fault in their markup and their text.
  *
  * @param {string} source - Authored Markdown: a note body, or a whole file
  *   whose frontmatter is blanked.
  * @param {RunContext} [ctx] - The configured languages, the installed faces
- *   and the maps. Without them every `lang=` must be a tag, every face and
- *   map is unknown, and only `mono`, `serif` and `sans` are fonts.
+ *   and the encodings. Without them every `lang=` must be a tag, every face and
+ *   enc is unknown, and only `mono`, `serif` and `sans` are fonts.
  * @param {import("./content-session.mjs").ContentSyntax} [syntax] - Session
  *   scanner projections, so the source's spans and blocks are scanned once.
- * @returns {{runs: Run[], errors: Array<{line: number, column: number, message: string}>, warnings: Array<{line: number, column: number, message: string}>}}
+ * @returns {{runs: Run[], errors: Array<{file?: string, line: number, column: number, message: string}>, warnings: Array<{line: number, column: number, message: string}>}}
  *   The runs in source order, and each finding at its 1-based position. A
  *   warning is a `lang=` read as a tag that sits within one edit of a
- *   declared name.
+ *   declared name. Diagnostic columns count Unicode code points; each run's
+ *   source offsets and column remain UTF-16 units.
  */
 export function scanRuns(source: string, ctx?: RunContext, syntax?: import("./content-session.mjs").ContentSyntax): {
     runs: Run[];
     errors: Array<{
+        file?: string;
         line: number;
         column: number;
         message: string;
@@ -43,13 +49,13 @@ export function scanRuns(source: string, ctx?: RunContext, syntax?: import("./co
     }>;
 };
 /**
- * Rewrite text marked with `lang=`, `font=` and `map=` into the plain span,
+ * Rewrite text marked with `lang=`, `font=` and `enc=` into the plain span,
  * div and verse grammar the rest of each chain renders, one line for one line.
  *
  * - **Numbered verse prefixes and indentation markers** stay outside run text.
  *   Each authored run chooses its own language and presentation; physical
  *   lines and source positions remain unchanged.
- * - **The map, if any, is applied first.** Characters Markdown would read are
+ * - **The enc, 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
@@ -63,19 +69,19 @@ export function scanRuns(source: string, ctx?: RunContext, syntax?: import("./co
  *   mark, `<bdo>` or `<bdi>` is ever written: the code points carry their own
  *   direction.
  * - **A scroll fence's body** is rewritten to one line per paragraph, its
- *   lines joined by what the map writes for a space, and left unescaped,
+ *   lines joined by what the enc writes for a space, and left unescaped,
  *   since the body is raw. Its layout, each character with the source text it
  *   was written from, is returned for the book, which draws it.
  *
  * A run with a finding is left as written; {@link scanRuns} reports it.
  *
  * @param {string} source - Authored Markdown: a note body.
- * @param {RunContext} [ctx] - The configured languages, faces and maps.
+ * @param {RunContext} [ctx] - The configured languages, faces and encodings.
  * @param {import("./content-session.mjs").ContentSyntax} [syntax] - Session
  *   scanner projections.
  * @param {{target?: "site"|"foundry"|"book"}} [options] - The target the
  *   Markdown is rendered for; only `site` writes the search marker.
- * @returns {{markdown: string, errors: Array<{line: number, column: number, message: string}>, scrolls: Map<string, import("./content-scroll.mjs").ScrollLayout>}}
+ * @returns {{markdown: string, errors: Array<{file?: string, line: number, column: number, message: string}>, scrolls: Map<string, import("./content-scroll.mjs").ScrollLayout>}}
  *   The rewritten Markdown, the findings of {@link scanRuns}, and each
  *   rewritten scroll fence's layout, by its rewritten body.
  */
@@ -84,6 +90,7 @@ export function renderRuns(source: string, ctx?: RunContext, syntax?: import("./
 }): {
     markdown: string;
     errors: Array<{
+        file?: string;
         line: number;
         column: number;
         message: string;
@@ -92,8 +99,6 @@ export function renderRuns(source: string, ctx?: RunContext, syntax?: import("./
 };
 /** The keys this module reads, which no construct passes through as written. */
 export const RUN_KEYS: readonly string[];
-/** Explicit opt-in to native-script presentation on this construct. */
-export const NATIVEFONT_CLASS: "nativefont";
 /** The generic families `font=` may name, each with the class that sets it. */
 export const GENERIC_FONTS: Readonly<{
     mono: "font-mono";
@@ -155,14 +160,14 @@ export type RunDetail = {
      */
     generic: string | undefined;
     /**
-     * - Its map.
+     * - Its enc.
      */
-    textMap: import("./text-maps.mjs").TextMap | undefined;
+    encoding: ReturnType<typeof import("./encoding.mjs").compileEncoding> | undefined;
     /**
-     * - Its map,
+     * - Its enc,
      * face and lexicon, which its text is set by.
      */
-    mapping: import("./map-lexicon.mjs").Mapping | undefined;
+    selection: ReturnType<typeof encodingFor> | undefined;
     /**
      * - The marked spans inside it.
      */
@@ -196,6 +201,16 @@ export type RunDetail = {
      * - The emphasis it holds, by absolute offset.
      */
     emphasis: Delimiter[];
+    /**
+     * - Its inline source structure permits Roman
+     * inventory validation, independently of encoding and face resolution.
+     */
+    checkRoman?: boolean | undefined;
+    /**
+     * - Its selection and source structure permit
+     * native encoding and output glyph validation.
+     */
+    checkText?: boolean | undefined;
     /**
      * - A scroll fence whose opening has a finding,
      * which is left as written.
@@ -206,6 +221,10 @@ export type RunDetail = {
  * What a run is checked against.
  */
 export type RunContext = {
+    /**
+     * - The citing content package.
+     */
+    contentPackage?: string | undefined;
     /**
      * - The
      * configured languages.
@@ -221,25 +240,73 @@ export type RunContext = {
     faces?: ReadonlyMap<string, import("./script-fonts.mjs").Face> | undefined;
     /**
      * -
-     * The mapping notes' maps by name, from
-     * {@link module :engine/text-maps.mapsFromRecords}.
+     * The compiled encoding documents, keyed by canonical and local Addresses.
+     */
+    encodings?: ReadonlyMap<string, Readonly<{
+        name: any;
+        language?: any;
+        font?: any;
+        template?: Readonly<{
+            normalization: "NFC";
+            vowelGroups: any;
+            maxVowelGroup: number;
+            stress: "󠄔" | undefined;
+            diaeresis: boolean;
+            grave: boolean;
+        }> | undefined;
+        fonts: readonly any[];
+        separator: any;
+        separatorRow: {
+            from: string;
+            to: any;
+            key: string;
+        };
+        vowels: Set<any>;
+        accepted: Set<any>;
+        controls: any;
+        groupCase: any;
+        roundTrip: any;
+        shared: {
+            rows: any;
+            index: Map<any, any>;
+            readings: Map<any, any>;
+        };
+        faces: Map<any, any>;
+        codes: {
+            rows: any;
+            index: Map<any, any>;
+            readings: Map<any, any>;
+        };
+    }>> | undefined;
+    /**
+     * - Encoding-document or font-code findings.
      */
-    maps?: ReadonlyMap<string, import("./text-maps.mjs").TextMap> | undefined;
+    encodingFindings?: readonly {
+        file?: string;
+        line?: number;
+        column?: number;
+        message: string;
+    }[] | undefined;
     /**
-     * -
-     * The script each configured language's note names, by language name, from
-     * {@link module :engine/written-in.writtenInOf}.
+     * - Serialized encoding documents and their selected font codes.
      */
-    writtenIn?: ReadonlyMap<string, import("./written-in.mjs").WrittenIn> | undefined;
+    encodingDefinitions?: ReadonlyMap<string, {
+        data: object;
+        codes: Record<string, string>;
+    }> | undefined;
+    /**
+     * - The configured language notes.
+     */
+    languageRecords?: ReadonlyMap<string, Record<string, any>> | undefined;
     /**
      * -
      * Each configured language's lexicon by name, from
-     * {@link module :engine/map-lexicon.lexiconsFromRecords}.
+     * {@link module :engine/encoding-lexicon.lexiconsFromRecords}.
      */
-    lexicons?: ReadonlyMap<string, import("./map-lexicon.mjs").Lexicon> | undefined;
+    lexicons?: ReadonlyMap<string, import("./encoding-lexicon.mjs").Lexicon> | undefined;
     /**
      * -
-     * What each configured language's mapped runs are checked against, from
+     * What each configured language's encoded runs are checked against, from
      * {@link module :engine/run-words.wordBooksFromRecords}.
      */
     wordBooks?: ReadonlyMap<string, import("./run-words.mjs").WordBook> | undefined;
@@ -279,11 +346,9 @@ export type RunContext = {
     directions?: ReadonlyMap<string, "vertical-rl"> | undefined;
 };
 /**
- * One span, div, verse fence or scroll fence carrying `lang=`, `font=` or
- * `map=`. Its `lang`, `font` and `map` are the ones it is set with: its own,
- * else inherited language or an ordinary prose family. Native map/face
- * defaults are selected only by this construct's explicit `.nativefont`
- * opt-in; marked children make their own presentation choice.
+ * One span, div, verse fence or scroll fence carrying run attributes.
+ * Values combine explicit choices, class-only inheritance, encoding-document
+ * language/font defaults and the Roman default encoding.
  */
 export type Run = {
     /**
@@ -304,9 +369,9 @@ export type Run = {
      */
     font: string | undefined;
     /**
-     * - The map as written.
+     * - The resolved document Address, or default for Roman text.
      */
-    map: string | undefined;
+    enc: string | undefined;
     /**
      * - 1-based line of the construct's opening.
      */
@@ -325,9 +390,5 @@ export type Run = {
      * fence's 0-based closing line.
      */
     end: number;
-    /**
-     * - True only for an explicit native opt-in
-     * with its own language; retained by index records for deferred defaults.
-     */
-    nativefont?: boolean | undefined;
 };
+import { encodingFor } from "./encoding-lexicon.mjs";

package/types/engine/converter-data.d.mts

@@ -0,0 +1,11 @@
+/** Return only the published definitions and lexical inputs the converter reads. */
+export function buildConverterData(config: any, records: any): import("../convert.mjs").ConverterData;
+/** Write opted-in converter inputs during the package's manifest build. */
+export function writeConverterData({ config, packageBuild, records }: {
+    config: any;
+    packageBuild: any;
+    records: any;
+}): {
+    path: string;
+    data: import("../convert.mjs").ConverterData;
+} | undefined;

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

@@ -1,28 +1,3 @@
-/**
- * A noun's stated plural, or the first literal ending replacement that fits.
- *
- * @param {{form: string, class?: unknown, plural?: unknown}} word - A word of
- *   `data.words`.
- * @param {Record<string, any>|undefined} grammar - Its language's
- *   `data.grammar`.
- * @returns {string|null} The plural, or `null` for a word that is no noun or
- *   that no rule fits.
- */
-export function pluralOf(word: {
-    form: string;
-    class?: unknown;
-    plural?: unknown;
-}, grammar: Record<string, any> | undefined): string | null;
-/**
- * The plural a language's `data.grammar.plural` rule gives a form: the first
- * literal ending replacement that fits, whatever the form's class.
- *
- * @param {string} form - The form.
- * @param {Record<string, any>|undefined} grammar - Its language's
- *   `data.grammar`.
- * @returns {string|null} The plural, or `null` where no rule fits.
- */
-export function pluralByRule(form: string, grammar: Record<string, any> | undefined): string | null;
 /**
  * The stable prose anchor of a word in one language's dictionary. The exact
  * language and NFC form identify it, including case and accents.
@@ -71,3 +46,4 @@ export const DICTIONARY_COLUMNS: readonly string[];
 export const TERM_COLUMNS: readonly string[];
 /** The keys of a word's `etymology`, in order. */
 export const ETYMOLOGY_KEYS: readonly string[];
+export { pluralOf, pluralByRule } from "./word-inflections.mjs";

package/types/engine/encoding-integrity.d.mts

@@ -0,0 +1,14 @@
+/** Prove ordinary output tokens uniquely decodable without adding invisible metadata. */
+/**
+ * Check codeword integrity with a trie and finite Sardinas–Patterson residuals.
+ * Source-equivalent compositions are redundant rules, not distinct spellings.
+ * @param {Array<{from:string,to:string,key:string,before?:string,at?:string}>} rows - Validated ordinary rows.
+ * @param {(key:string,message:string)=>never} fault - Positioned schema-error constructor.
+ */
+export function assertUniqueOutputs(rows: Array<{
+    from: string;
+    to: string;
+    key: string;
+    before?: string;
+    at?: string;
+}>, fault: (key: string, message: string) => never): void;

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

@@ -0,0 +1,36 @@
+/**
+ * Encode using the lexicon's own and composed writings before the encoding rows.
+ * @param {ReturnType<import("./encoding.mjs").compileEncoding>} enc
+ * @param {string} text
+ * @param {{font?:string,verse?:boolean,lexicon?:{language:string,data:Record<string,any>}}} [options]
+ * @returns {{text:string,pieces:object[],findings:object[]}}
+ */
+export function encodeWithLanguage(enc: ReturnType<typeof import("./encoding.mjs").compileEncoding>, text: string, options?: {
+    font?: string;
+    verse?: boolean;
+    lexicon?: {
+        language: string;
+        data: Record<string, any>;
+    };
+}): {
+    text: string;
+    pieces: object[];
+    findings: object[];
+};
+/**
+ * Decode with explicit writings first and recover unmarked words from the lexicon.
+ * @param {ReturnType<import("./encoding.mjs").compileEncoding>} enc
+ * @param {string} text
+ * @param {{font?:string,lexicon?:{language:string,data:Record<string,any>}}} [options]
+ * @returns {{text:string,findings:object[]}}
+ */
+export function decodeWithLanguage(enc: ReturnType<typeof import("./encoding.mjs").compileEncoding>, text: string, options?: {
+    font?: string;
+    lexicon?: {
+        language: string;
+        data: Record<string, any>;
+    };
+}): {
+    text: string;
+    findings: object[];
+};

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

@@ -0,0 +1,259 @@
+/**
+ * Each configured language's lexicon, read from the language note its `note`
+ * names and its family chain. The nearest exact NFC form supplies the whole
+ * word; grammar, registers and other settings remain the daughter's own.
+ * A language with no `note`, or one naming no language note, has none.
+ *
+ * @param {Iterable<Record<string, any>>|undefined} records - Index records.
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
+ *   The resolved configuration.
+ * @returns {Map<string, Lexicon>} The lexicons by language name.
+ */
+export function lexiconsFromRecords(records: Iterable<Record<string, any>> | undefined, config?: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+}): Map<string, Lexicon>;
+/**
+ * The language note each configured language's `note` names, by language
+ * name. A language with no `note`, or one naming no language note, is absent.
+ *
+ * @param {Iterable<Record<string, any>>|undefined} records - Index records.
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
+ *   The resolved configuration.
+ * @returns {Map<string, Record<string, any>>} The records.
+ */
+export function languageRecordsByName(records: Iterable<Record<string, any>> | undefined, { languages, contentPackage }?: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+}): Map<string, Record<string, any>>;
+/**
+ * Each `languages.<name>.note` that names no language note, at its key.
+ *
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string, configFile?: string, configText?: string}} config -
+ *   The resolved configuration, and where it was read from.
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {object[]} The findings.
+ */
+export function languageNoteFindings(config: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+    configFile?: string;
+    configText?: string;
+}, records: Iterable<Record<string, any>>): object[];
+/**
+ * One row per native form of a language note's word, for the `natives`
+ * relation: a text is a value of a row, never a struct key, so forms that
+ * differ only in case stay apart.
+ *
+ * @param {Iterable<Record<string, any>>} records - Index records.
+ * @returns {Array<Record<string, string|number|null>>} The rows; `word` is the
+ *   word's 0-based place in `data.words`, `native` the form's in its `native`.
+ */
+export function nativeRows(records: Iterable<Record<string, any>>): Array<Record<string, string | number | null>>;
+/** Project only conversion-readable language data to a JSON-safe object. */
+export function serializeLexicon(lexicon: any): {
+    language: any;
+    data: {
+        grammar?: {
+            [k: string]: any;
+        } | undefined;
+        words: {
+            [k: string]: any;
+        }[];
+        affixes: {
+            [k: string]: any;
+        }[];
+        register: {
+            [k: string]: any;
+        }[];
+    };
+} | undefined;
+/**
+ * Resolve encoding, face and optional language input without loading files.
+ *
+ * @param {import("./content-scripts.mjs").RunContext} ctx - Installed encodings,
+ *   document aliases and lexicons prepared by the caller.
+ * @param {object} [options] - Explicit selections; an omitted encoding is the Roman default.
+ * @param {string} [options.enc] - Encoding document Address.
+ * @param {string} [options.font] - The encoding document's font.
+ * @param {string} [options.lang] - Configured language whose lexicon to use.
+ */
+export function encodingFor(ctx: import("./content-scripts.mjs").RunContext, { enc, font, lang }?: {
+    enc?: string | undefined;
+    font?: string | undefined;
+    lang?: string | undefined;
+}): {
+    encoding: Readonly<{
+        name: any;
+        language?: any;
+        font?: any;
+        template?: Readonly<{
+            normalization: "NFC";
+            vowelGroups: any;
+            maxVowelGroup: number;
+            stress: "󠄔" | undefined;
+            diaeresis: boolean;
+            grave: boolean;
+        }> | undefined;
+        fonts: readonly any[];
+        separator: any;
+        separatorRow: {
+            from: string;
+            to: any;
+            key: string;
+        };
+        vowels: Set<any>;
+        accepted: Set<any>;
+        controls: any;
+        groupCase: any;
+        roundTrip: any;
+        shared: {
+            rows: any;
+            index: Map<any, any>;
+            readings: Map<any, any>;
+        };
+        faces: Map<any, any>;
+        codes: {
+            rows: any;
+            index: Map<any, any>;
+            readings: Map<any, any>;
+        };
+    }>;
+    font: any;
+    lexicon: {
+        language: any;
+        data: {
+            grammar?: {
+                [k: string]: any;
+            } | undefined;
+            words: {
+                [k: string]: any;
+            }[];
+            affixes: {
+                [k: string]: any;
+            }[];
+            register: {
+                [k: string]: any;
+            }[];
+        };
+    } | undefined;
+} | undefined;
+/** Why a face is incompatible with the selected encoding. */
+export function fontProblem(encoding: any, font: any): string | undefined;
+/** List authored and optionally derived forms with their selected native writings. */
+export function lexiconEntries(ctx: any, { lang, enc, font, derived }: {
+    lang: any;
+    enc: any;
+    font: any;
+    derived?: boolean | undefined;
+}): {
+    about: string;
+    problem: string;
+    entries?: undefined;
+} | {
+    entries: {
+        from?: any;
+        ambiguous?: boolean | undefined;
+        form: any;
+        native: string;
+        class: any;
+        gloss: any;
+        source: string;
+        exception: boolean;
+    }[];
+    about?: undefined;
+    problem?: undefined;
+};
+/** Validate word, affix and grammar-ending native entries against installed encodings. */
+export function checkLexiconNatives(note: any, ctx: any): any[];
+/** Validate every authored word and name against its language's encoding documents.
+ * @param {{fm:Record<string,any>,file:string,raw?:string}} note - The source language note.
+ * @param {import("./content-scripts.mjs").RunContext} ctx - Compiled documents and language identities.
+ * @returns {object[]} Positioned orthography findings, independent of lexical native overrides.
+ */
+export function checkEncodingLexicon(note: {
+    fm: Record<string, any>;
+    file: string;
+    raw?: string;
+}, ctx: import("./content-scripts.mjs").RunContext): object[];
+/** Every column of the `natives` relation, in order. */
+export const NATIVE_COLUMNS: readonly string[];
+/**
+ * One native form, read.
+ */
+export type NativeForm = {
+    /**
+     * - The encoding it is written for.
+     */
+    enc: string;
+    /**
+     * - The one face it is for.
+     */
+    font: string | undefined;
+    /**
+     * - The word in the script.
+     */
+    text: string;
+};
+/**
+ * One word of a lexicon.
+ */
+export type LexiconWord = {
+    /**
+     * - The word as cited.
+     */
+    form: string;
+    /**
+     * - Its class.
+     */
+    class: string | null;
+    /**
+     * - Its senses, joined by `; `.
+     */
+    gloss: string | null;
+    /**
+     * - Its native forms.
+     */
+    natives: readonly NativeForm[];
+};
+/**
+ * A language's lexicon.
+ */
+export type Lexicon = {
+    /**
+     * - The language's configured name.
+     */
+    language: string;
+    /**
+     * - Its words, in `data.words` order.
+     */
+    words: readonly LexiconWord[];
+    /**
+     * - The native
+     * forms by the word's form, NFC; the first word of a form keeps it.
+     */
+    byForm: ReadonlyMap<string, readonly NativeForm[]>;
+    /**
+     * - The
+     * forms the language's rules derive from its words, folded, as the mapped-run
+     * word check accepts them (see {@link module :engine/word-forms.derivedForms}).
+     */
+    derived: ReadonlyArray<{
+        form: string;
+        from: LexiconWord;
+    }>;
+    /**
+     * - The language note's `data`, which a
+     * encoding writes words from.
+     */
+    data: Record<string, any>;
+};

package/types/engine/encoding-notes.d.mts

@@ -0,0 +1,39 @@
+/** Complete an encoding reference with the document type and citing package.
+ * @param {unknown} value - Authored encoding Address or default.
+ * @param {string} [contentPackage] - The citing note's package.
+ * @returns {string|undefined} Canonical Address, default, or an invalid reference.
+ */
+export function encodingAddress(value: unknown, contentPackage?: string): string | undefined;
+/** The executable fields a document owns, excluding ordinary document metadata.
+ * @param {Record<string, any>} data - Authored document data.
+ * @returns {Record<string, any>} Only the compiler's fields.
+ */
+export function encodingData(data: Record<string, any>): Record<string, any>;
+/** Read this selected face's published glyph codes, with no external code tables.
+ * @param {import("./script-fonts.mjs").ScriptFonts|undefined} fonts - Consumer fonts.
+ * @param {string} font - The selected face's slug.
+ * @returns {Record<string,string>} Code-to-Unicode mapping for this font only.
+ */
+export function fontCodes(fonts: import("./script-fonts.mjs").ScriptFonts | undefined, font: string): Record<string, string>;
+/** Compile each encoding document once and resolve references by document Address.
+ * @param {Iterable<Record<string, any>>} records - Content index records.
+ * @param {{languages?: Record<string, any>, contentPackage?: string, rootDir?: string, paths?: {content?: string}}} [config] - Consumer context.
+ * @param {import("./script-fonts.mjs").ScriptFonts} [fonts] - Installed glyph metadata.
+ * @returns {{encodings: Map<string, ReturnType<typeof compileEncoding>>, definitions: Map<string,{data:Record<string,any>,codes:Record<string,string>}>, findings:object[]}} Runtime and serializable document inputs.
+ */
+export function encodingsFromRecords(records: Iterable<Record<string, any>>, config?: {
+    languages?: Record<string, any>;
+    contentPackage?: string;
+    rootDir?: string;
+    paths?: {
+        content?: string;
+    };
+}, fonts?: import("./script-fonts.mjs").ScriptFonts): {
+    encodings: Map<string, ReturnType<typeof compileEncoding>>;
+    definitions: Map<string, {
+        data: Record<string, any>;
+        codes: Record<string, string>;
+    }>;
+    findings: object[];
+};
+import { compileEncoding } from "./encoding.mjs";

package/types/engine/encoding-standard.d.mts

@@ -0,0 +1,11 @@
+/** Shared Roman punctuation and invisible structural controls for every encoding. */
+export const STANDARD_ROWS: readonly Readonly<unknown>[];
+/** Controls belong to the engine and never come from font encoding files. */
+export const STANDARD_CONTROLS: Readonly<{
+    verseStanza: "󠄍";
+    verseCanto: "󠄎";
+    wordSeparator: " ";
+    literalOpen: "󠄒";
+    literalClose: "󠄓";
+    literalEscape: "󠄕";
+}>;