@heroiclands/package-build 24.0.1 → 24.0.3

package/types/engine/font-outlines.d.mts

@@ -0,0 +1,67 @@
+/**
+ * The outlines of a TrueType face, read once per file.
+ *
+ * @param {string} file - The `.ttf`.
+ * @returns {Outlines} Its outlines.
+ * @throws {Error} When the file is not a TrueType face with outlines.
+ */
+export function fontOutlines(file: string): Outlines;
+/**
+ * One panel of a scroll as SVG: its columns read from the right, `rows` ems
+ * tall, each character centred in its column, in red where it is set in the
+ * rubric and with a line beside it, on the right, where it is overlined.
+ *
+ * @param {import("./content-scroll.mjs").ScrollCell[][]} panel - Its columns,
+ *   the first the rightmost.
+ * @param {number} rows - The characters in a column.
+ * @param {Outlines} outlines - The face.
+ * @returns {string} The SVG.
+ */
+export function scrollPanelSvg(panel: import("./content-scroll.mjs").ScrollCell[][], rows: number, outlines: Outlines): string;
+/** The book's rubric red, which its preamble names `book-rubric`. */
+export const BOOK_RUBRIC: "#9c281b";
+/** The book's ink, which its preamble names `book-ink`. */
+export const BOOK_INK: "#241f1a";
+/**
+ * A point of a contour.
+ */
+export type Point = {
+    x: number;
+    y: number;
+    on: boolean;
+};
+/**
+ * One glyph, in font units, its y axis pointing down from the baseline.
+ */
+export type Glyph = {
+    /**
+     * - Its glyph index.
+     */
+    index: number;
+    /**
+     * - Its outline as SVG path data; `""` for none.
+     */
+    d: string;
+    /**
+     * - Its horizontal advance.
+     */
+    advance: number;
+    /**
+     * - From the top of its cell to its baseline.
+     */
+    top: number;
+};
+/**
+ * A face's outlines.
+ */
+export type Outlines = {
+    /**
+     * - Its units per em.
+     */
+    unitsPerEm: number;
+    /**
+     * - The glyph a code
+     * point is drawn with, or `undefined` when the face does not draw it.
+     */
+    glyph: (point: number) => Glyph | undefined;
+};

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

@@ -6,6 +6,19 @@
  * @returns {boolean}
  */
 export function tongueDeclared(tag: string, declared: Set<string>): boolean;
+/**
+ * Check a `doc` note's `data.sounds`, a spelling guide's letters and marks:
+ * each letter row's `tongue` names language notes. The data-key check owns
+ * the keys, so a sound rule a guide does not state is refused there.
+ *
+ * @param {object} note - A `doc` note: `file`, `raw` and parsed `fm`.
+ * @param {object} [context]
+ * @param {object} [context.index] - The index, for whether an Address resolves.
+ * @returns {object[]} The findings.
+ */
+export function checkGuideSounds(note: object, { index }?: {
+    index?: object | undefined;
+}): object[];
 /**
  * Check a `skill` note's language data against what it means.
  *

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

@@ -42,8 +42,8 @@ export function tongueRows(records: Iterable<Record<string, any>>): object[];
  */
 export function scopeRows(records: Iterable<Record<string, any>>): object[];
 /**
- * The `letters` rows: one per `data.sounds.letters` entry, `letters` and
- * `tongue` lists.
+ * The `letters` rows: one per `data.sounds.letters` entry of a language note
+ * or a spelling guide, `letters` and `tongue` lists.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {object[]}
@@ -207,14 +207,15 @@ export function joiningRows(records: Iterable<Record<string, any>>): object[];
  */
 export function joinRows(records: Iterable<Record<string, any>>): object[];
 /**
- * The `marks` rows: one per `data.sounds.marks` entry.
+ * The `marks` rows: one per `data.sounds.marks` entry of a language note or a
+ * spelling guide.
  *
  * @param {Iterable<Record<string, any>>} records - Index records.
  * @returns {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/language-terms.d.mts

@@ -233,6 +233,13 @@ export const MUTATION_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
  * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
 export const SOUND_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys of a spelling guide's `data.sounds`: a `doc` note stating the
+ * letters and marks every tongue of a setting is written by.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const GUIDE_SOUND_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
 /**
  * The keys of one `data.soundChanges` entry.
  *

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

@@ -151,14 +151,15 @@ export function transliterate(ctx: object, keys: {
  * 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.
+ * @param {{lang: string, map?: string, font?: string, derived?: boolean}} keys -
+ *   The language, the map, the face, and whether to list derived forms. A map
+ *   or a face left out is the one the language's `data.writtenIn` names.
  * @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 }: {
     lang: string;
-    map: string;
+    map?: string;
     font?: string;
     derived?: boolean;
 }): {

package/types/engine/pdf-build.d.mts

@@ -14,33 +14,16 @@
  * 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: string, config: object, opts?: {
-    foreignIndex?: Map<string, object> | undefined;
-    resolveReplacement?: Function | undefined;
-}): {
+export function stagedImagePath(src: string, config: object): {
     from: string;
     to: string;
 } | null;
@@ -134,10 +117,6 @@ export function listBookAssets({ config, version, out }?: {
  *   {@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}>,
@@ -149,7 +128,7 @@ export function listBookAssets({ config, version, out }?: {
  *   every declared book whichever was requested; both are empty when a book's
  *   selection could not be read.
  */
-export function buildPdf({ config, configPath, book, out, version, compile, readPages, resolveReplacement, }?: {
+export function buildPdf({ config, configPath, book, out, version, compile, readPages, }?: {
     config?: object | undefined;
     configPath?: string | undefined;
     book?: string | undefined;
@@ -157,7 +136,6 @@ export function buildPdf({ config, configPath, book, out, version, compile, read
     version?: string | undefined;
     compile?: boolean | undefined;
     readPages?: Function | undefined;
-    resolveReplacement?: Function | undefined;
 }): Promise<{
     built: boolean;
     reason: string | null;

package/types/engine/pdf-fonts.d.mts

@@ -1,3 +1,13 @@
+/**
+ * The tables an sfnt file holds, by tag.
+ *
+ * @param {Buffer} buf - The font file.
+ * @returns {Map<string, {offset: number, length: number}>} Its table directory.
+ */
+export function tableDirectory(buf: Buffer): Map<string, {
+    offset: number;
+    length: number;
+}>;
 /**
  * Every glyph name a font carries, with the codepoint that reaches it.
  *

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

@@ -2,12 +2,14 @@
  * One run as an index record carries it.
  *
  * @typedef {object} RecordRun
- * @property {"span"|"block"|"verse"} kind - The construct.
+ * @property {"span"|"block"|"verse"|"scroll"} kind - The construct.
  * @property {string|null} lang - The language it is set in, as written: its
  *   own `lang=`, else the one the div or fence around it states.
  * @property {string|null} tag - The BCP 47 tag it resolves to, or null.
- * @property {string|null} font - Its font, as written and inherited the same way.
- * @property {string|null} map - Its map, as written and inherited the same way.
+ * @property {string|null} font - Its font, as written and inherited the same
+ *   way, else its language's script's.
+ * @property {string|null} map - Its map, as written and inherited the same way,
+ *   else its language's script's.
  * @property {number} line - 1-based file line of its opening.
  * @property {number} column - 1-based UTF-16 file column of its opening.
  */
@@ -33,6 +35,24 @@ export function recordRuns(body: string, { context, bodyLine, bodyColumn, syntax
     bodyColumn?: number | undefined;
     syntax?: import("./content-session.mjs").ContentSyntax | undefined;
 }): RecordRun[];
+/**
+ * Give every recorded run the map and face its language's note names in
+ * `data.writtenIn`, where the run leaves them unstated, as a run is set. Read
+ * once every record exists, since a run's language note may be recorded after
+ * the note that marks it.
+ *
+ * @param {Record<string, any>[]} records - The package's index records; each
+ *   note record's `runs` is updated in place.
+ * @param {{languages?: Readonly<Record<string, {tag: string, note?: string}>>, contentPackage?: string}} config -
+ *   The configured languages, whose `note` names each language note.
+ */
+export function fillWrittenIn(records: Record<string, any>[], config: {
+    languages?: Readonly<Record<string, {
+        tag: string;
+        note?: string;
+    }>>;
+    contentPackage?: string;
+}): void;
 /**
  * The containing page's NOTE identity.
  *
@@ -57,7 +77,7 @@ export type RecordRun = {
     /**
      * - The construct.
      */
-    kind: "span" | "block" | "verse";
+    kind: "span" | "block" | "verse" | "scroll";
     /**
      * - The language it is set in, as written: its
      * own `lang=`, else the one the div or fence around it states.
@@ -68,11 +88,13 @@ export type RecordRun = {
      */
     tag: string | null;
     /**
-     * - Its font, as written and inherited the same way.
+     * - Its font, as written and inherited the same
+     * way, else its language's script's.
      */
     font: string | null;
     /**
-     * - Its map, as written and inherited the same way.
+     * - Its map, as written and inherited the same way,
+     * else its language's script's.
      */
     map: string | null;
     /**

package/types/engine/script-direction.d.mts

@@ -0,0 +1,10 @@
+/**
+ * Each face's direction, from the script notes among the index records. The
+ * first note to list a face keeps it; a face whose note states no direction,
+ * or one the build does not know, is absent.
+ *
+ * @param {Iterable<Record<string, any>>|undefined} records - Index records.
+ * @returns {Map<string, "vertical-rl">} The directions, by face slug.
+ */
+export function directionsFromRecords(records: Iterable<Record<string, any>> | undefined): Map<string, "vertical-rl">;
+export { SCRIPT_DIRECTIONS } from "./script-emphasis-terms.mjs";

package/types/engine/script-emphasis-terms.d.mts

@@ -1,7 +1,8 @@
 /**
- * **The words a script note and a language note state emphasis by.** Read by
- * the vocabulary as it is declared, so this module imports nothing; the
- * checks and the conventions' use are in {@link module:engine/script-emphasis}.
+ * **The words a script note and a language note state emphasis and direction
+ * by.** Read by the vocabulary as it is declared, so this module imports
+ * nothing; the checks and the conventions' use are in
+ * {@link module:engine/script-emphasis} and {@link module:engine/script-direction}.
  *
  * @module
  */
@@ -17,5 +18,11 @@ export const EMPHASIS_CLASSES: Readonly<{
  * `words` marks emphasis with a word, so a mark in its text is a finding.
  */
 export const LANGUAGE_EMPHASES: readonly string[];
+/**
+ * The directions a script states it is written in. `vertical-rl` is columns,
+ * top to bottom, read from the right; a script stating none is written in
+ * lines.
+ */
+export const SCRIPT_DIRECTIONS: readonly string[];
 /** The `subType` of a script note. */
 export const SCRIPT_SUBTYPE: "script";

package/types/engine/script-font-delivery.d.mts

@@ -1,7 +1,9 @@
 /**
- * The faces the package's notes set text in with `font=`, read from the
- * notes themselves: every Markdown file under the content tree that writes
- * `font=` is scanned for its runs.
+ * The faces the package's notes set text in, read from the notes
+ * themselves: every Markdown file under the content tree that writes `font=`
+ * is scanned for its runs, and the face every language note names in
+ * `data.writtenIn` counts, since a run marked with the language alone is set
+ * in it.
  *
  * @param {DeliveryConfig} config - The resolved configuration.
  * @param {import("./script-fonts.mjs").ScriptFonts} installed - The fonts package.

package/types/engine/script-fonts.d.mts

@@ -28,6 +28,9 @@
  * @property {string} direction - `ltr` or `rtl`.
  * @property {string[]} features - OpenType features it turns on.
  * @property {ReadonlySet<number>} draws - Every code point it draws.
+ * @property {string|undefined} file - The absolute path of its TrueType file,
+ *   which the book draws a `scroll` fence's outlines from; `undefined` when the
+ *   manifest lists none.
  */
 /**
  * The installed fonts package, as a consumer sees it.
@@ -140,6 +143,12 @@ export type Face = {
      * - Every code point it draws.
      */
     draws: ReadonlySet<number>;
+    /**
+     * - The absolute path of its TrueType file,
+     * which the book draws a `scroll` fence's outlines from; `undefined` when the
+     * manifest lists none.
+     */
+    file: string | undefined;
 };
 /**
  * The installed fonts package, as a consumer sees it.

package/types/engine/site-reach.d.mts

@@ -67,6 +67,17 @@ export function splitContent(html: string): {
  * @returns {string} The sections, or `""` when nothing is left.
  */
 export function pruneGenerated(html: string, outside: (href: string) => boolean): string;
+/**
+ * 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: string, outside: (href: string) => boolean, className: string): string;
 /**
  * The comment that separates a page's authored text from the sections the
  * build generated after it, in the HTML the renderer writes.

package/types/engine/written-in.d.mts

@@ -0,0 +1,76 @@
+/**
+ * Whether a map is drawn in a face: it lists the face, or lists none.
+ *
+ * @param {import("./text-maps.mjs").TextMap} map - The map.
+ * @param {string} font - The face's slug.
+ * @returns {boolean} Whether the map may set text in it.
+ */
+export function drawnIn(map: import("./text-maps.mjs").TextMap, font: string): boolean;
+/**
+ * The script each configured language's note names, where the map is known
+ * and is drawn in the face. A default that names an unknown map or a face its
+ * map is not drawn in is the note's finding, and fills no run.
+ *
+ * @param {ReadonlyMap<string, Record<string, any>>} byName - Each configured
+ *   language's note record, by language name, from
+ *   {@link module:engine/map-lexicon.languageRecordsByName}.
+ * @param {ReadonlyMap<string, import("./text-maps.mjs").TextMap>} maps - The
+ *   maps by name.
+ * @returns {Map<string, WrittenIn>} The scripts, by language name.
+ */
+export function writtenInOf(byName: ReadonlyMap<string, Record<string, any>>, maps: ReadonlyMap<string, import("./text-maps.mjs").TextMap>): Map<string, WrittenIn>;
+/**
+ * The keys a run takes from its language's script: each of `map` and `font`
+ * the run does not state, where it agrees with the one the run does.
+ *
+ * @param {{lang?: string, map?: string, font?: string}} keys - The run's keys,
+ *   its own and those it inherits.
+ * @param {ReadonlyMap<string, WrittenIn>|undefined} scripts - Each language's
+ *   script, from {@link writtenInOf}.
+ * @param {ReadonlyMap<string, import("./text-maps.mjs").TextMap>|undefined} maps -
+ *   The maps by name.
+ * @returns {{map?: string, font?: string}} What the run takes; empty when it
+ *   takes nothing.
+ */
+export function fromWrittenIn(keys: {
+    lang?: string;
+    map?: string;
+    font?: string;
+}, scripts: ReadonlyMap<string, WrittenIn> | undefined, maps: ReadonlyMap<string, import("./text-maps.mjs").TextMap> | undefined): {
+    map?: string;
+    font?: string;
+};
+/**
+ * Check a note's `data.writtenIn`: that the note is a language, that `map`
+ * names a map a mapping note declares, and that the map is drawn in `font`.
+ * The data-key check owns the keys and their kinds.
+ *
+ * @param {{file: string, raw?: string, fm?: Record<string, any>}} note - The note.
+ * @param {{index?: {notes?: Iterable<object>}}} [context] - The lint index;
+ *   without one, only the note's `subType` is checked.
+ * @returns {object[]} The findings, each at its key or value.
+ */
+export function checkWrittenIn(note: {
+    file: string;
+    raw?: string;
+    fm?: Record<string, any>;
+}, { index }?: {
+    index?: {
+        notes?: Iterable<object>;
+    };
+}): object[];
+/** The `data` key a language note names its script in. */
+export const WRITTEN_IN_KEY: "writtenIn";
+/**
+ * A language's script.
+ */
+export type WrittenIn = {
+    /**
+     * - The `data.map.name` of the mapping note.
+     */
+    map: string;
+    /**
+     * - The slug of the face, one the map is drawn in.
+     */
+    font: string;
+};

package/engine/asset-replacement.mjs

@@ -1,93 +0,0 @@
-/*
- * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
- * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
- *
- * This work is licensed under the GNU General Public License v3.0 (GPLv3).
- * You may copy, modify, and distribute it under the terms of that license.
- *
- * For full terms, see the LICENSE.md file in the project root or visit:
- * https://www.gnu.org/licenses/gpl-3.0.html
- *
- * SPDX-License-Identifier: GPL-3.0-or-later
- */
-
-/**
- * A declared replacement package's asset record, picked over the local one,
- * by address.
- *
- * A package may declare, on a `relationships.<kind>[]` entry, that a
- * dependency's asset tree answers its own asset addresses —
- * `assetReplacement: true` in `package-build.config.yaml`:
- *
- * ```yaml
- * relationships:
- *     requires:
- *         - id: thalornaaltart
- *           manifest: https://…/releases/latest/download/module.json
- *           assetReplacement: true
- *           contentIndex: true
- * ```
- *
- * `assetReplacement: true` opts that relationship in. `resolveAssetReplacement`
- * is what turns the declaration into an answer, one address at a time, against
- * four rules:
- *
- * 1. **Scoped to asset types.** A non-asset address, or one whose package
- *    segment is not the compiling package's own, resolves to `null` at once —
- *    tested with {@link module:engine/asset-types.isAssetType} rather than
- *    reimplemented. A being, an item or a lore note is never replaced this
- *    way.
- * 2. **Ordered, single pass.** Replacements are tried in declaration order —
- *    the order their relationships appear in `package-build.config.yaml` —
- *    and the first one carrying the address wins.
- * 3. **Never recursive.** A replacement's own output address is not itself
- *    looked up against another replacement: resolving
- *    `thalornaaltart-none-image-thorn` never asks whether something replaces
- *    `thalornaaltart`. This forecloses a cycle by construction — there is
- *    nothing to loop.
- * 4. **A miss falls through.** `null` means no declared replacement carries
- *    the address, and the caller falls back to the local address exactly as
- *    it does today. This function never decides that a missing replacement is
- *    an error; a caller that wants that is free to build it on the answer.
- *
- * This resolver answers a different question from
- * {@link module:engine/asset-bindings.checkForeignAssetBindings}: that check
- * validates an art module's own staged files against another package's
- * addresses, at that module's own build time. This one runs at the *replaced*
- * package's build, consulted by its book, and asks whether a declared
- * replacement carries an address this package would otherwise answer itself.
- *
- * @module
- */
-
-import { isAssetType } from "./asset-types.mjs";
-import { canonicalKey, readCanonicalKey } from "./content-address.mjs";
-
-/**
- * The replacement record for one asset address, or `null`.
- *
- * @param {string} address - A canonical asset address.
- * @param {object} opts
- * @param {string} opts.localPackage - The compiling package's own segment.
- * @param {readonly string[]} opts.replacements - The package segments of
- *   every relationship declaring `assetReplacement: true`, in declaration
- *   order.
- * @param {Map<string, object>} opts.index - The merged content index, keyed
- *   by canonical address.
- * @returns {{record: object, package: string}|null} The first replacement
- *   carrying the address, or `null` when none does.
- */
-export function resolveAssetReplacement(address, { localPackage, replacements, index }) {
-    const parts = readCanonicalKey(address);
-    if (!parts) return null;
-    if (!isAssetType(parts.type)) return null;
-    if (parts.package !== localPackage) return null;
-    for (const replacementPackage of replacements ?? []) {
-        const key = canonicalKey(replacementPackage, parts.system, parts.type, parts.shortcode);
-        const record = index?.get(key);
-        if (record?.asset?.path && record.package) {
-            return { record, package: replacementPackage };
-        }
-    }
-    return null;
-}

package/types/engine/asset-replacement.d.mts

@@ -1,22 +0,0 @@
-/**
- * The replacement record for one asset address, or `null`.
- *
- * @param {string} address - A canonical asset address.
- * @param {object} opts
- * @param {string} opts.localPackage - The compiling package's own segment.
- * @param {readonly string[]} opts.replacements - The package segments of
- *   every relationship declaring `assetReplacement: true`, in declaration
- *   order.
- * @param {Map<string, object>} opts.index - The merged content index, keyed
- *   by canonical address.
- * @returns {{record: object, package: string}|null} The first replacement
- *   carrying the address, or `null` when none does.
- */
-export function resolveAssetReplacement(address: string, { localPackage, replacements, index }: {
-    localPackage: string;
-    replacements: readonly string[];
-    index: Map<string, object>;
-}): {
-    record: object;
-    package: string;
-} | null;