@heroiclands/package-build 24.0.2 → 24.0.4

package/engine/map-lexicon.mjs

@@ -59,7 +59,7 @@ import { fromWrittenIn } from "./written-in.mjs";
 import { writingsOf } from "./logographic.mjs";
 import { FONTS_PACKAGE } from "./script-fonts.mjs";
 import { GENERIC_FAMILIES, applyMap } from "./text-maps.mjs";
-import { isLanguageRecord, noteAddressOf } from "./word-rows.mjs";
+import { isLanguageRecord, lineageChain, noteAddressOf } from "./word-rows.mjs";
 import { derivedForms } from "./word-forms.mjs";
 import { LANGUAGE_SUBTYPE, glossText } from "./word-terms.mjs";
 
@@ -183,7 +183,7 @@ function lexiconOf(language, data) {
  * @returns {string|undefined} The Address.
  */
 function noteKey(note, contentPackage, types) {
-    if (typeof note !== "string" || !contentPackage) return undefined;
+    if (!contentPackage) return undefined;
     const tuple = parseAddress(
         note,
         { package: contentPackage, system: "note", type: "skill", types: new Set(types) },
@@ -248,7 +248,9 @@ function languageNotes(languages, contentPackage, records) {
 
 /**
  * Each configured language's lexicon, read from the language note its `note`
- * names. A language with no `note`, or one naming no language note, has none.
+ * 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 -
@@ -256,9 +258,39 @@ function languageNotes(languages, contentPackage, records) {
  * @returns {Map<string, Lexicon>} The lexicons by language name.
  */
 export function lexiconsFromRecords(records, config = {}) {
+    const list = [...(records ?? [])];
+    const byKey = recordsByKey(list, config.contentPackage);
+    const types = new Set(["skill", ...list.map((record) => record?.type).filter(Boolean)]);
+    const lineage = {
+        has: (key) => isLanguage(byKey.get(key)),
+        parentOf: (key) => {
+            const record = byKey.get(key);
+            return noteKey(record.data?.family, record.package ?? config.contentPackage, types);
+        },
+    };
     const lexicons = new Map();
-    for (const [name, record] of languageRecordsByName(records, config))
-        lexicons.set(name, lexiconOf(name, record.data));
+    for (const [name, { key, record }] of languageNotes(
+        config.languages,
+        config.contentPackage,
+        list,
+    )) {
+        if (!record) continue;
+        const chain = lineageChain(key, lineage);
+        let data = record.data;
+        if (chain.length > 1) {
+            const words = new Map();
+            for (const ancestor of chain)
+                for (const word of listOf(byKey.get(ancestor).data?.words)) {
+                    if (!isMap(word) || typeof word.form !== "string") continue;
+                    // The nearest complete definition wins before word matching
+                    // folds case or splits compounds. Only words are inherited.
+                    const form = word.form.normalize("NFC");
+                    if (!words.has(form)) words.set(form, word);
+                }
+            data = { ...data, words: [...words.values()] };
+        }
+        lexicons.set(name, lexiconOf(name, data));
+    }
     return lexicons;
 }
 

package/engine/pdf-build.mjs

@@ -124,15 +124,7 @@ import {
     pdfTextWidth,
     resamplePdfImages,
 } from "./pdf-images.mjs";
-import {
-    ASSETS_SEGMENT,
-    assetPathnameKey,
-    pathnameProblem,
-    resolvePathname,
-} from "./pathnames.mjs";
-import { ASSET_SYSTEM, assetTypeOfRoot, isAssetShortcode } from "./asset-types.mjs";
-import { canonicalKey } from "./address.mjs";
-import { isComplete as isForeignCacheComplete, newestVersionDir } from "./metadata-index.mjs";
+import { assetPathnameKey, pathnameProblem, resolvePathname } from "./pathnames.mjs";
 import {
     createParser,
     labelFor,
@@ -147,7 +139,6 @@ import { noteInfoboxes } from "./infobox-registry.mjs";
 import { resolveIconGlyphs } from "./pdf-fonts.mjs";
 import { drawMapsFrom } from "./derived-sections.mjs";
 import { generatedDrawing } from "./generated-sections.mjs";
-import { resolveAssetReplacement } from "./asset-replacement.mjs";
 import { typstScriptFontPath } from "./script-font-delivery.mjs";
 
 /**
@@ -166,39 +157,18 @@ import { typstScriptFontPath } from "./script-font-delivery.mjs";
  * a build from touching a path outside its own output.
  *
  * A file **this** package ships stages directly. A pathname naming another
- * package's file stages instead from a declared replacement's cached archive,
- * when `opts.resolveReplacement` — the pure function
- * {@link module:engine/asset-replacement.resolveAssetReplacement} —
- * answers it; `opts.foreignIndex` is the merged index that answer is read
- * against. A pathname naming a package no replacement carries it for, or a
- * URL, names something no build here can open — a build reaches no network —
- * and the caller reports it as a picture the book will not carry.
+ * package's file, or a URL, names something no build here can open — a build
+ * reaches no network — and the caller reports it as a picture the book will
+ * not carry.
  *
  * @param {string} src - The pathname, as authored.
  * @param {object} config - The resolved configuration.
- * @param {object} [opts]
- * @param {Map<string, object>} [opts.foreignIndex] - Every fetched
- *   dependency's own records, keyed by canonical address — the index a
- *   replacement's record is read out of.
- * @param {Function} [opts.resolveReplacement] - {@link
- *   module:engine/asset-replacement.resolveAssetReplacement}, or an
- *   equivalent a caller injects for a test. Omitted, a foreign pathname this
- *   package does not own stays declined exactly as it always has.
  * @returns {{from: string, to: string}|null} The file, and where under the
  *   output directory it is staged.
- * @throws {Error} When a declared replacement answers the address but its
- *   archive was never fetched.
  */
-export function stagedImagePath(src, config, opts = {}) {
+export function stagedImagePath(src, config) {
     const forms = resolvePathname(src, config);
     if (!forms || forms.state !== "package") return null;
-    // A declared replacement answers before the package's own file does, which
-    // is the whole of what declaring one buys: the address a note writes is
-    // this package's own, and the picture staged for it is the replacement's.
-    // A miss falls through, so a package declaring none stages exactly what it
-    // ships.
-    const replaced = opts.resolveReplacement ? stagedReplacementPath(forms, config, opts) : null;
-    if (replaced) return replaced;
     if (forms.own) {
         return {
             from: path.resolve(config.rootDir, forms.local),
@@ -208,126 +178,6 @@ export function stagedImagePath(src, config, opts = {}) {
     return null;
 }
 
-/**
- * Every declared relationship that opted a dependency in as this package's
- * asset replacement, in declaration order.
- *
- * The same shape {@link module:engine/foreign-catalog.itemCatalogRelationships}
- * returns, read directly rather than through that module: this file stays a
- * leaf over the configuration it is handed, and the flag is as small to read
- * back as it was to validate.
- *
- * @param {object} config - The resolved build configuration.
- * @returns {Array<{id: string, package: string}>} The relationships, each
- *   with the package segment its own content index publishes under.
- */
-function assetReplacementRelationships(config) {
-    const out = [];
-    for (const entries of Object.values(config.relationships ?? {})) {
-        for (const rel of entries ?? []) {
-            if (rel.assetReplacement) {
-                out.push({ id: rel.id, package: rel.contentPackage ?? rel.id });
-            }
-        }
-    }
-    return out;
-}
-
-/**
- * The address a pathname this package does not own is read back as, for
- * asking whether a declared replacement answers it instead of the package
- * the pathname names.
- *
- * {@link module:engine/asset-replacement.resolveAssetReplacement} only ever
- * matches an address whose package segment is the compiling package's own,
- * so the pathname's own package is set aside and its suffix — the one piece
- * every surface derives from, and the piece a replacement publishes under
- * its own package instead — is read back as this package's type and
- * shortcode.
- *
- * @param {import("./pathnames.mjs").PathnameForms} forms - The pathname,
- *   resolved.
- * @param {object} config - The resolved build configuration.
- * @returns {string|null} The canonical address, or `null` when the suffix is
- *   not shaped like an asset's.
- */
-function localAssetAddress(forms, config) {
-    const segments = String(forms.suffix ?? "").split("/");
-    const assetType = assetTypeOfRoot(segments[0]);
-    if (!assetType) return null;
-    const base = segments[segments.length - 1];
-    const ext = path.extname(base);
-    const shortcode = (ext ? base.slice(0, -ext.length) : base).toLowerCase();
-    if (!isAssetShortcode(shortcode)) return null;
-    return canonicalKey(config.contentPackage, ASSET_SYSTEM, assetType.type, shortcode);
-}
-
-/**
- * The cache directory one relationship's archive was fetched into, found the
- * way {@link module:engine/foreign-catalog.foreignItemCatalogDirs} finds an
- * item catalogue's: the newest `.complete`-stamped `<id>@<version>`
- * directory under `config.paths.foreignCache`.
- *
- * @param {object} config - The resolved build configuration.
- * @param {string} id - The relationship's dependency id.
- * @returns {string|null} The directory, or `null` when nothing is cached.
- */
-function cachedReplacementDir(config, id) {
-    const root = config.paths.foreignCache;
-    if (!fs.existsSync(root)) return null;
-    const cached = fs
-        .readdirSync(root)
-        .filter((name) => name.startsWith(`${id}@`))
-        .map((name) => path.join(root, name))
-        .filter(isForeignCacheComplete);
-    return cached.length ? newestVersionDir(cached) : null;
-}
-
-/**
- * The file a declared replacement stages in place of a pathname this package
- * does not own, or `null` when no replacement answers it.
- *
- * @param {import("./pathnames.mjs").PathnameForms} forms - The pathname,
- *   resolved, with `forms.own` already `false`.
- * @param {object} config - The resolved build configuration.
- * @param {object} opts
- * @param {Map<string, object>} [opts.foreignIndex] - Every fetched
- *   dependency's own records, keyed by canonical address.
- * @param {Function} opts.resolveReplacement - {@link
- *   module:engine/asset-replacement.resolveAssetReplacement}.
- * @returns {{from: string, to: string}|null} The file, staged at the same
- *   `pdf`-relative path this address would have taken had this package
- *   shipped it.
- * @throws {Error} When the replacement that answers the address has not
- *   been fetched.
- */
-function stagedReplacementPath(forms, config, { foreignIndex = new Map(), resolveReplacement }) {
-    const address = localAssetAddress(forms, config);
-    if (!address) return null;
-    const relationships = assetReplacementRelationships(config);
-    if (!relationships.length) return null;
-    const hit = resolveReplacement(address, {
-        localPackage: config.contentPackage,
-        replacements: relationships.map((rel) => rel.package),
-        index: foreignIndex,
-    });
-    if (!hit) return null;
-    const assetPath = hit.record?.asset?.path;
-    if (!assetPath) return null;
-    const rel = relationships.find((entry) => entry.package === hit.package);
-    const dir = cachedReplacementDir(config, rel?.id ?? hit.package);
-    if (!dir) {
-        throw new Error(
-            `\`${hit.package}\` declares \`assetReplacement: true\` and carries \`${address}\`, ` +
-                "but its archive has not been fetched. Run `package-build deps fetch` first.",
-        );
-    }
-    return {
-        from: path.join(dir, ASSETS_SEGMENT, assetPath),
-        to: forms.pdf,
-    };
-}
-
 /**
  * Where the book keeps the pictures its section plates are drawn over.
  *
@@ -553,10 +403,6 @@ function configFileFor(config, rootDir) {
  *   {@link module:engine/pdf-pages}.
  * @param {Function} [opts.readPages] - {@link
  *   module:engine/pdf-pages.readEntryPages}, for tests.
- * @param {Function} [opts.resolveReplacement] - {@link
- *   module:engine/asset-replacement.resolveAssetReplacement}, for tests.
- *   Loaded from that module otherwise, and only when a relationship declares
- *   `assetReplacement: true` — a build with none never imports it.
  * @returns {Promise<{built: boolean, reason: string|null, findings: object[],
  *   imageReports: object[], books: Array<{id: string, title: string,
  *   built: boolean, typ: string, pdf: string|null, stats: object}>,
@@ -576,7 +422,6 @@ export async function buildPdf({
     version = "",
     compile = true,
     readPages = readEntryPages,
-    resolveReplacement,
 } = {}) {
     const resolved = config ?? loadPackConfig();
     const findings = [];
@@ -642,7 +487,7 @@ export async function buildPdf({
         out || resolved.pdf.out || path.join("build", "dist"),
     );
 
-    const world = await prepareWorld(resolved, { contentBase, findings, resolveReplacement });
+    const world = await prepareWorld(resolved, { contentBase, findings });
     if (!world) return none(null);
 
     const books = [];
@@ -944,11 +789,10 @@ function locateType(contentBase, record) {
  * @param {object} shared - Options.
  * @param {string} shared.contentBase - The content tree.
  * @param {object[]} shared.findings - Collected here rather than thrown.
- * @param {Function} [shared.resolveReplacement] - As {@link buildPdf}.
  * @returns {Promise<object|null>} The world, or null when a site gate fired
  *   and the findings say why.
  */
-async function prepareWorld(resolved, { contentBase, findings, resolveReplacement }) {
+async function prepareWorld(resolved, { contentBase, findings }) {
     // The corpus, once — the same records the index, the site and the SQL
     // tables read, so the book cannot select a note the other surfaces do not
     // have.
@@ -1038,17 +882,6 @@ async function prepareWorld(resolved, { contentBase, findings, resolveReplacemen
     const md = createParser(resolved.icons);
     const glyphs = resolveIconGlyphs(resolved.icons, resolved.pdf.iconFonts, findings);
 
-    // Asked only where a relationship declares `assetReplacement: true`: with
-    // none declared the resolver is never consulted, and staging gives the
-    // answer it gives a package that declares no replacement. A caller may
-    // supply its own, which is how the staging tests drive it.
-    const stagingOpts = {
-        foreignIndex: gates.foreign.index,
-        resolveReplacement:
-            resolveReplacement ??
-            (assetReplacementRelationships(resolved).length ? resolveAssetReplacement : null),
-    };
-
     return {
         records,
         db,
@@ -1060,7 +893,6 @@ async function prepareWorld(resolved, { contentBase, findings, resolveReplacemen
         assets,
         md,
         glyphs,
-        stagingOpts,
     };
 }
 
@@ -1150,7 +982,6 @@ async function selectBook(book, index, { world, configFile, configText, findings
  * @param {{get: Function}} [shared.elsewhere] - From
  *   {@link module:engine/pdf-pages.elsewhereFor}: the notes another book is
  *   home to, which this book names by book and page rather than links.
- * @param {Function} [shared.resolveReplacement] - As {@link buildPdf}.
  * @param {object[]} shared.findings - Collected here rather than thrown.
  * @returns {Promise<{built: boolean, typ: string|null, pdf: string|null,
  *   stats: object|null, imageReports?: object[]}>} What was written: the
@@ -1178,10 +1009,10 @@ async function buildBook(book, shared) {
      * @returns {{from: string, to: string}|null} As {@link stagedImagePath}.
      */
     const stage = (src) => {
-        const staged = stagedImagePath(src, resolved, world.stagingOpts);
+        const staged = stagedImagePath(src, resolved);
         return staged && { ...staged, to: inBook(staged.to) };
     };
-    const { records, site, gates, byFile, sqlTables, assets, md, glyphs, stagingOpts } = world;
+    const { records, site, gates, byFile, sqlTables, assets, md, glyphs } = world;
 
     fs.mkdirSync(outDir, { recursive: true });
 

package/engine/run-words.mjs

@@ -36,7 +36,7 @@
  * @module
  */
 
-import { languageRecordsByName } from "./map-lexicon.mjs";
+import { lexiconsFromRecords } from "./map-lexicon.mjs";
 import { RESERVED_TONGUE } from "./language-terms.mjs";
 import { addWords, foldWord, lexiconWords } from "./word-forms.mjs";
 import { WORD } from "./word-pattern.mjs";
@@ -82,7 +82,8 @@ export function registeredNameWords(data) {
 
 /**
  * Each configured language's word book: one per language whose `note` names a
- * language note.
+ * language note. Its effective lexicon shares the renderer's nearest inherited
+ * words, and derives forms and registered names from its own settings.
  *
  * @param {Iterable<Record<string, any>>|undefined} records - Index records.
  * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
@@ -92,11 +93,10 @@ export function registeredNameWords(data) {
 export function wordBooksFromRecords(records, config = {}) {
     const list = [...(records ?? [])];
     const books = new Map();
-    const languages = languageRecordsByName(list, config);
-    if (!languages.size) return books;
-    for (const [name, record] of languages) {
-        const own = lexiconWords(record.data);
-        const names = registeredNameWords(record.data);
+    const lexicons = lexiconsFromRecords(list, config);
+    for (const [name, lexicon] of lexicons) {
+        const own = lexiconWords(lexicon.data);
+        const names = registeredNameWords(lexicon.data);
         books.set(
             name,
             Object.freeze({

package/engine/site-reach.mjs

@@ -211,3 +211,26 @@ export function pruneGenerated(html, outside) {
     });
     return kept.join("");
 }
+
+/**
+ * Entries' links set as plain text where they lead outside a set of pages.
+ * Each link is the only child of a span carrying the class.
+ *
+ * @param {string} html - A page body.
+ * @param {(href: string) => boolean} outside - Whether an `href` names a page
+ *   of the site that is not to be linked.
+ * @param {string} className - The class the entries' links carry.
+ * @returns {string} The body with each such `<a>` replaced by its content.
+ */
+export function unlinkEntries(html, outside, className) {
+    const marked = new RegExp(
+        `<span\\b[^>]*?\\sclass=(?:"[^"]*\\b${className}\\b[^"]*"|'[^']*\\b${className}\\b[^']*')[^>]*>(<a\\b[^>]*>[\\s\\S]*?</a>)</span>`,
+        "gi",
+    );
+    return String(html ?? "").replace(marked, (span, anchor) => {
+        const match = new RegExp(ANCHOR.source, "i").exec(anchor);
+        const href = match ? (match[1] ?? match[2] ?? match[3] ?? "").replace(/&amp;/g, "&") : "";
+        if (href === "" || !outside(href)) return span;
+        return anchor.replace(/^<a\b[^>]*>/, "").replace(/<\/a>$/, "");
+    });
+}

package/engine/site-render.mjs

@@ -69,6 +69,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
+import { LEXICAL_LINK_CLASS } from "./dictionary-layout.mjs";
 import { createRenderer } from "./content-render.mjs";
 import { resolvePathname } from "./pathnames.mjs";
 import { minifyHtml } from "./html-minify.mjs";
@@ -82,7 +83,13 @@ import {
 import { buildSite, gatesFailed } from "./site-build.mjs";
 import { readCachedNavigation, siteSettings } from "./site-config.mjs";
 import { atomFeed, robotsTxt, sitemapIndexXml, sitemapXml } from "./site-files.mjs";
-import { pageAddress, pruneGenerated, reachablePages, splitContent } from "./site-reach.mjs";
+import {
+    pageAddress,
+    pruneGenerated,
+    reachablePages,
+    splitContent,
+    unlinkEntries,
+} from "./site-reach.mjs";
 import { prepareTreeSqlTables } from "./sql-tables.mjs";
 import { placeGeography, searchMetadata } from "./site-search.mjs";
 import {
@@ -369,7 +376,12 @@ export function writeSite({ site, pages, out, report, staticDir = SITE_STATIC_DI
             },
             report: sink,
         });
-    const authoredOf = (page) => splitContent(page.content).authored;
+    const authoredOf = (page) =>
+        unlinkEntries(
+            splitContent(page.content).authored,
+            (url) => pageOfUrl(url) !== undefined,
+            LEXICAL_LINK_CLASS,
+        );
     const first = makeTheme({
         visible: (url) => pageOfUrl(url) === undefined,
         contentOf: authoredOf,
@@ -405,7 +417,10 @@ export function writeSite({ site, pages, out, report, staticDir = SITE_STATIC_DI
     const contentOf = (page) => {
         if (page.content === undefined) return page.content;
         const { authored, generated } = splitContent(page.content);
-        return authored + pruneGenerated(generated, outside);
+        return (
+            unlinkEntries(authored, outside, LEXICAL_LINK_CLASS) +
+            pruneGenerated(generated, outside)
+        );
     };
     const theme = makeTheme({ visible: (url) => !outside(url), contentOf, report });
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "24.0.2",
+    "version": "24.0.4",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",
@@ -184,6 +184,7 @@
     },
     "devDependencies": {
         "@changesets/cli": "^3.0.0",
+        "@heroiclands/fonts": "^0.1.5",
         "@types/node": "^26.2.0",
         "esbuild": "^0.28.2",
         "markdownlint": "^0.42.0",

package/types/content-config.d.mts

@@ -313,8 +313,7 @@ export type PathsInput = {
     unpack?: string | undefined;
     /**
      * Where a dependency declaring
-     *      `itemCatalog: true` or
-     *      `assetArchive: true` is unpacked.
+     *      `itemCatalog: true` is unpacked.
      *      Inbound, and fetched rather than
      *      committed.
      */
@@ -486,13 +485,6 @@ export type RelationshipSpec = {
      *  does not hold. Needs a `manifest`.
      */
     itemCatalog?: boolean | undefined;
-    /**
-     * Whether `deps fetch` unpacks this
-     * dependency's release archive for its
-     * asset bytes alone, building no item
-     * catalogue from it. Needs a `manifest`.
-     */
-    assetArchive?: boolean | undefined;
     /**
      * Whether `deps fetch` fetches this
      * dependency's content index. Default
@@ -504,16 +496,6 @@ export type RelationshipSpec = {
      * index.
      */
     contentIndex?: boolean | undefined;
-    /**
-     * Whether this dependency's asset
-     * tree answers this package's own asset
-     * addresses ahead of its local record.
-     * Default `false`. Refuses `contentIndex:
-     * false` on the same entry, since a
-     * replacement with no fetched index to
-     * check against resolves nothing.
-     */
-    assetReplacement?: boolean | undefined;
 };
 /**
  * How a generated documentation page is framed in the repository publishing it.

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

@@ -60,6 +60,11 @@ export const LAYOUT_REQUIRED_COLUMNS: Readonly<{
 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";
+/**
+ * The class on every link an entry writes to another note, so a site can set
+ * the link as plain text where its target is not a page a reader can reach.
+ */
+export const LEXICAL_LINK_CLASS: "lexical-ref";
 export type LayoutOptions = {
     /**
      * - Whether an Address can be

package/types/engine/foreign-catalog.d.mts

@@ -11,20 +11,6 @@ export function itemCatalogRelationships(config: object): Array<{
     kind: string;
     verified: string | undefined;
 }>;
-/**
- * Every declared relationship that opted into supplying its release archive
- * for asset bytes alone, with no item catalogue built from it.
- *
- * @param {object} config - The resolved build configuration.
- * @returns {Array<{id: string, manifest: string, kind: string, verified: string|undefined}>}
- *   The opted-in relationships, in declaration order.
- */
-export function assetArchiveRelationships(config: object): Array<{
-    id: string;
-    manifest: string;
-    kind: string;
-    verified: string | undefined;
-}>;
 /**
  * The cache directory for one dependency at one version.
  *
@@ -109,26 +95,6 @@ export function fetchCatalog(config: object, rel: {
     id: string;
     manifest: string;
 }): Promise<string>;
-/**
- * Fetch one dependency's release archive for its asset bytes alone, building
- * no item catalogue from it.
- *
- * Idempotent: a complete cache for the resolved version is left alone. Where a
- * relationship also declares `itemCatalog: true`, {@link fetchCatalog} already
- * unpacked this same archive into this same cache directory, and
- * {@link fetchAllCatalogs} does not call this function for it — the two never
- * download the same bytes twice.
- *
- * @param {object} config - The resolved build configuration.
- * @param {{id: string, manifest: string, verified?: string}} rel - The
- *   declared relationship.
- * @returns {Promise<string>} The dependency's cache directory.
- */
-export function fetchAssetArchive(config: object, rel: {
-    id: string;
-    manifest: string;
-    verified?: string;
-}): Promise<string>;
 /**
  * Fill the cache from a locally built artifact rather than a release.
  *
@@ -202,10 +168,6 @@ export function fetchAllMetadata(config: object): Promise<number>;
 /**
  * Fetch every opted-in dependency. The `deps fetch` command.
  *
- * A relationship declaring both `itemCatalog: true` and `assetArchive: true`
- * is fetched once: {@link fetchCatalog} already unpacks the archive on its
- * way to extracting the item catalogue, so this skips the archive-only fetch
- * for any id {@link fetchCatalog} already handled.
  *
  * @param {object} config - The resolved build configuration.
  * @returns {Promise<number>} How many dependencies were fetched.

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

@@ -215,7 +215,7 @@ export function joinRows(records: Iterable<Record<string, any>>): object[];
  */
 export function markRows(records: Iterable<Record<string, any>>): object[];
 /**
- * The `skeleton` rows: one per `data.sounds.skeleton` entry, `second` a list.
+ * The `skeleton` rows: one per `data.sounds.skeleton` entry, `second` and `third` lists.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}

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

@@ -1,6 +1,8 @@
 /**
  * Each configured language's lexicon, read from the language note its `note`
- * names. A language with no `note`, or one naming no language note, has none.
+ * 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 -