@heroiclands/package-build 24.0.2 → 24.0.3

package/engine/dictionary-layout.mjs

@@ -68,6 +68,19 @@ export const COMMON_MARK = "•";
 /** 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";
+
+/** Wikilinks in a gloss, marked with {@link LEXICAL_LINK_CLASS}. */
+const markLinks = (text) =>
+    String(text ?? "").replace(
+        /\[\[[^\]]*\]\](?!\{)/g,
+        (link) => `${link}{.${LEXICAL_LINK_CLASS}}`,
+    );
+
 /**
  * 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.
@@ -327,7 +340,7 @@ function render(
         const text = label(address);
         const ref = parseAddress(address, addressContext ?? {}, { declared: true });
         if (ref.reason || !linkable(ref)) return text;
-        return `[[${renderAddress(ref)}|${String(text).replace(/\|/g, "/")}]]`;
+        return `[[${renderAddress(ref)}|${String(text).replace(/\|/g, "/")}]]{.${LEXICAL_LINK_CLASS}}`;
     };
     const tag = (language, text) => {
         if (!text) return "";
@@ -367,7 +380,7 @@ function render(
             const { address, anchor } = splitAnchor(row.word);
             const ref = readCanonicalKey(address);
             if (ref && anchor && linkable(ref))
-                headword = `**[[${renderAddress(ref)}#${anchor}|${String(row.name).replace(/\|/g, "/")}]]**`;
+                headword = `**[[${renderAddress(ref)}#${anchor}|${String(row.name).replace(/\|/g, "/")}]]{.${LEXICAL_LINK_CLASS}}**`;
         }
         parts.push(headword);
         if (row.pronunciation) parts.push(`/${row.pronunciation}/`);
@@ -401,7 +414,7 @@ function render(
             const bodies = Array.isArray(sense?.bodies) ? sense.bodies : [];
             const by =
                 bodies.length && !sense.omitBody ? `(_${bodies.map(label).join(", ")}_) ` : "";
-            return `${by}${sentence(sense?.text)}`;
+            return `${by}${markLinks(sentence(sense?.text))}`;
         };
         if (senses.length === 1) parts.push(senseText(senses[0]));
         else senses.forEach((sense, i) => parts.push(`**${i + 1}** ${senseText(sense)}`));

package/engine/foreign-catalog.mjs

@@ -38,12 +38,6 @@
  * local pack's output — the resolution logic needs no knowledge of where an
  * item came from.
  *
- * `assetArchive: true` is the sibling flag, for a dependency whose bytes are
- * wanted and whose items are not: an asset-replacement source such as
- * `thalornaaltart` ships no Item packs at all. It unpacks the same release
- * archive without extracting anything from it, so a relationship declaring
- * both flags on one entry is fetched once rather than twice.
- *
  * **The network is never touched by a compile.** Fetching is its own command
  * (`package-build deps fetch`), and a compile whose cache is cold fails saying
  * so. A build that silently downloads is not reproducible, fails strangely
@@ -78,22 +72,17 @@ import {
 const STAMP = ".complete";
 
 /**
- * Every declared relationship carrying a given flag, in declaration order.
- *
- * Shared by {@link itemCatalogRelationships} and
- * {@link assetArchiveRelationships}: both read the same shape out of the same
- * walk, filtered on a different key.
+ * Every declared relationship that opted into supplying an item catalogue.
  *
  * @param {object} config - The resolved build configuration.
- * @param {"itemCatalog"|"assetArchive"} flag - Which boolean to filter on.
  * @returns {Array<{id: string, manifest: string, kind: string, verified: string|undefined}>}
- *   The opted-in relationships.
+ *   The opted-in relationships, in declaration order.
  */
-function flaggedRelationships(config, flag) {
+export function itemCatalogRelationships(config) {
     const out = [];
     for (const [kind, entries] of Object.entries(config.relationships ?? {})) {
         for (const rel of entries ?? []) {
-            if (rel[flag]) {
+            if (rel.itemCatalog) {
                 out.push({
                     id: rel.id,
                     manifest: rel.manifest,
@@ -106,29 +95,6 @@ function flaggedRelationships(config, flag) {
     return out;
 }
 
-/**
- * Every declared relationship that opted into supplying an item catalogue.
- *
- * @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 itemCatalogRelationships(config) {
-    return flaggedRelationships(config, "itemCatalog");
-}
-
-/**
- * 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) {
-    return flaggedRelationships(config, "assetArchive");
-}
-
 /**
  * The cache directory for one dependency at one version.
  *
@@ -401,21 +367,14 @@ export function pinnedManifestUrl(url, verified) {
 }
 
 /**
- * Resolve a dependency's manifest, pinned to `compatibility.verified` the way
- * both fetch paths require.
- *
- * Shared by {@link fetchCatalog} and {@link fetchAssetArchive}: both read the
- * same manifest before deciding what to unpack from it.
+ * Resolve a dependency's manifest, pinned to `compatibility.verified`.
  *
  * @param {{id: string, manifest: string, verified?: string}} rel - The
  *   declared relationship.
- * @param {string} subject - What floats when no version is verified —
- *   "catalogue" or "archive" — named in the warning a reader would otherwise
- *   get no word for.
  * @returns {Promise<{manifest: object, version: string}>} The manifest and
  *   its resolved version.
  */
-async function resolveManifest(rel, subject) {
+async function resolveManifest(rel) {
     const { url, pinned } = pinnedManifestUrl(rel.manifest, rel.verified);
     const manifest = await fetchManifest(url);
     const version = manifest.version;
@@ -432,7 +391,7 @@ async function resolveManifest(rel, subject) {
     }
     if (!rel.verified) {
         log.warn(
-            `${rel.id}: no \`compatibility.verified\`, so its ${subject} floats ` +
+            `${rel.id}: no \`compatibility.verified\`, so its catalogue floats ` +
                 `with whatever ${url} currently serves`,
         );
     }
@@ -449,7 +408,7 @@ async function resolveManifest(rel, subject) {
  * @returns {Promise<string>} The dependency's cache directory.
  */
 export async function fetchCatalog(config, rel) {
-    const { manifest, version } = await resolveManifest(rel, "catalogue");
+    const { manifest, version } = await resolveManifest(rel);
     const dir = catalogDir(config, rel.id, version);
     if (isComplete(dir)) {
         log.info(`${rel.id}@${version}: already cached`);
@@ -475,61 +434,6 @@ export async function fetchCatalog(config, rel) {
     return dir;
 }
 
-/**
- * Whether an asset-archive-only cache is present and complete.
- *
- * No item catalogue is built on this path, so completeness never asks for
- * `item-packs.json` — an asset-only dependency, such as `thalornaaltart`,
- * ships none.
- *
- * @param {string} dir - The dependency's cache directory.
- * @returns {boolean} True when the archive was fetched to completion.
- */
-const isArchiveComplete = (dir) => fs.existsSync(path.join(dir, STAMP));
-
-/**
- * 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 async function fetchAssetArchive(config, rel) {
-    const { manifest, version } = await resolveManifest(rel, "archive");
-    const dir = catalogDir(config, rel.id, version);
-    if (isArchiveComplete(dir)) {
-        log.info(`${rel.id}@${version}: already cached`);
-        return dir;
-    }
-
-    const download = manifest.download;
-    if (!download) {
-        throw new Error(`${rel.id}@${version}: its manifest declares no \`download\``);
-    }
-
-    // Rebuild from empty: a previous run may have died partway, and a stale
-    // half-tree is worse than no tree.
-    fs.rmSync(dir, { recursive: true, force: true });
-    const raw = path.join(dir, "package");
-    fs.mkdirSync(raw, { recursive: true });
-
-    log.info(`${rel.id}@${version}: downloading ${download}`);
-    await downloadAndUnzip(download, raw);
-
-    cacheSchemaArtifact(raw, dir);
-    // Last, so a fetch that died partway is never mistaken for a complete one.
-    fs.writeFileSync(path.join(dir, STAMP), `${version}\n`);
-    return dir;
-}
-
 /**
  * Locate a declared pack inside an unpacked archive.
  *
@@ -811,33 +715,18 @@ export async function fetchAllMetadata(config) {
 /**
  * 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.
  */
 export async function fetchAllCatalogs(config) {
     const itemRels = itemCatalogRelationships(config);
-    const archiveRels = assetArchiveRelationships(config);
-    if (!itemRels.length && !archiveRels.length) {
-        log.info(
-            "No relationship declares `itemCatalog: true` or `assetArchive: true`; " +
-                "nothing to fetch.",
-        );
+    if (!itemRels.length) {
+        log.info("No relationship declares `itemCatalog: true`; nothing to fetch.");
         return 0;
     }
     for (const rel of itemRels) await fetchCatalog(config, rel);
-    const alreadyFetched = new Set(itemRels.map((rel) => rel.id));
-    let archiveFetched = 0;
-    for (const rel of archiveRels) {
-        if (alreadyFetched.has(rel.id)) continue;
-        await fetchAssetArchive(config, rel);
-        archiveFetched++;
-    }
-    return itemRels.length + archiveFetched;
+    return itemRels.length;
 }
 
 /**

package/engine/language-rows.mjs

@@ -253,7 +253,7 @@ export const LANGUAGE_COLUMN_TYPES = Object.freeze({
     joining: { position: "BIGINT", first: LIST, second: LIST },
     joins: { position: "BIGINT", letters: LIST },
     marks: { position: "BIGINT", letters: LIST },
-    skeleton: { position: "BIGINT", second: LIST },
+    skeleton: { position: "BIGINT", second: LIST, third: LIST },
     frames: {
         position: "BIGINT",
         class: LIST,
@@ -911,14 +911,14 @@ export function markRows(records) {
 }
 
 /**
- * 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[]}
  */
 export function skeletonRows(records) {
     return listRows(records, (data) => soundsOf(data).skeleton, SKELETON_KEYS, {
-        lists: ["second"],
+        lists: ["second", "third"],
     });
 }
 

package/engine/language-terms.mjs

@@ -152,7 +152,7 @@ export const JOIN_MEETINGS = Object.freeze(["C+C", "V+C", "V+V"]);
 export const JOIN_RULES = Object.freeze(["merge", "insert", "drop", "double"]);
 
 /** What a written mark says of its letter. */
-export const MARK_KINDS = Object.freeze(["stress", "length"]);
+export const MARK_KINDS = Object.freeze(["stress", "length", "apart"]);
 
 /** How many of a mark a word may carry: `one` at most, or `any` number. */
 export const MARK_LIMITS = Object.freeze(["one", "any"]);
@@ -831,6 +831,12 @@ export const SKELETON_FIELDS = Object.freeze([
         required: true,
         describe: "The second consonants of a root the row holds for; `any` for every other.",
     }),
+    Object.freeze({
+        name: "third",
+        ...SOUNDS_OR_ANY,
+        describe:
+            "The third consonants of a root the row holds for; every third consonant where absent.",
+    }),
     Object.freeze({
         name: "between",
         kind: "string",

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/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.3",
     "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",