@heroiclands/package-build 22.17.1 → 22.18.0

package/engine/systems.mjs

@@ -20,10 +20,8 @@
  * address grammar asks on every note, and the issue's answer is that it comes
  * from a **registry rather than from a hardcoded set**: known system ids are
  * declared here, once, an unknown value is an error, and _adding a system is a
- * data change_. Before this module the same fact was spelled in as many places
- * as needed it — a `NO_SYSTEM` constant in the content index, a `map.system`
- * per document-subtype map, a system-keyed table per compiler — none of which
- * could refuse a value none of the others had heard of.
+ * data change_. The same fact is read by address parsing, configuration and
+ * linting.
  *
  * **`none` is a word, deliberately.** It is not a YAML null (`null`, `~`, or an
  * empty value), because those spell "nobody filled this in", and a note that
@@ -38,8 +36,8 @@
  * the configuration loader, by a compiler, and by a lint without closing a
  * cycle around any of them. In particular the ids are *declared* here rather
  * than derived from `KNOWN_DOCUMENT_SUBTYPE_MAPS` — deriving them would drag
- * `sohl/` and `hm3/` behind every import of this file, for a list of two
- * words. `tests/systems.test.ts` holds the two in step instead, which is where
+ * system-specific modules behind every import of this file. `tests/systems.test.ts`
+ * holds the registry and note-key vocabulary in step, which is where
  * the agreement between a registry and its implementations belongs.
  *
  * @module
@@ -66,11 +64,11 @@ export const NO_SYSTEM = "none";
 export const NOTE_SYSTEM = "note";
 
 /**
- * Every game system this toolchain compiles for.
+ * Every game system identifier this toolchain recognizes.
  *
- * The registry, and the only place the list is written down. Adding a system
- * is an edit to this set plus the map and compilers that make it real — a data
- * change, not a search for every place a name was spelled.
+ * The registry, and the only place the list is written down. A recognized id
+ * can have no system-specific document types; adding one of those requires a
+ * subtype map and compiler as well.
  *
  * `none` is **not** a member: it marks the absence of a system, and a caller
  * asking "is this a system" and a caller asking "is this a well-formed
@@ -79,7 +77,7 @@ export const NOTE_SYSTEM = "note";
  *
  * @type {ReadonlySet<string>}
  */
-export const SYSTEM_IDS = Object.freeze(new Set(["sohl", "hm3"]));
+export const SYSTEM_IDS = Object.freeze(new Set(["sohl", "hm3", "dnd5e"]));
 
 /**
  * Everything the `<system>` segment of an address may say.
@@ -127,8 +125,8 @@ export function isSystemSegment(value) {
  *
  * The nullish case is called out by name because it is the likely mistake and
  * the least legible failure: a YAML `null`, a `~`, or a key written with no
- * value at all reaches here as `undefined`, and "expected one of sohl, hm3,
- * none" would leave a reader hunting for the value they cannot see.
+ * value at all reaches here as `undefined`, and a list of accepted values
+ * would leave a reader hunting for the value they cannot see.
  *
  * @param {unknown} value - The offending value.
  * @param {string} [where] - What carried it, for the message — a note path, a

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "22.17.1",
+    "version": "22.18.0",
     "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",

package/types/engine/actor-compiler.d.mts

@@ -230,11 +230,10 @@ export class SystemActorCompiler extends BasePackCompiler {
      * The actor's two pieces of art, resolved, with the being default beneath
      * them.
      *
-     * **The default is chosen from the note's tags**, which only a compiler can
-     * read: a `character` falls back to one file and a `creature` to another,
-     * and both are addresses in the package that ships them. A tree whose index
-     * cannot answer that address — a dependency not yet fetched — falls through
-     * to the subtype's own default, so the document is never left with no art.
+     * **The default follows the note's `subType`**. Both addresses belong to
+     * the package that ships them. A tree whose index cannot answer an
+     * address — a dependency not yet fetched — falls through to the document
+     * subtype's own default, so the document is never left with no art.
      *
      * `tokenIcon` unset follows `icon`, and the fallback is applied after
      * resolution rather than before: a note naming an icon and no token icon

package/types/engine/address-diff.d.mts

@@ -1,12 +1,9 @@
 /**
  * The one spelling of an address in this space: `type:shortcode`.
  *
- * Written by both readers — the compiled packs on each side of the diff, and
- * the declarations read out of the tree — so a predecessor a note names and an
- * address a pack publishes cannot come apart over punctuation or case. The
- * shortcode is used **verbatim**, not lowercased: `readItemAddresses` reads it
- * off the compiled document, where `Tabri` is stored as authored, and folding
- * case here would join two addresses the packs keep apart.
+ * Used for addresses read from compiled documents. The shortcode is used
+ * **verbatim**, not lowercased: folding case would join two addresses the packs
+ * keep apart.
  *
  * @param {string} type - The Foundry document subtype, not the note type.
  * @param {string} shortcode - The address's `system.shortcode`.
@@ -39,89 +36,24 @@ export function readItemAddresses(dirs: readonly string[]): Map<string, {
     shortcode: string;
     file: string;
 }>;
-/**
- * Every rename the tree's notes **declare**, as old address → where it went.
- *
- * Read from the content tree rather than from compiled output, because a
- * declaration is authored and the compiled document does not carry it: nothing
- * downstream consumes `renamedFrom:`, so emitting it into every pack to let one
- * diagnostic read it back would put a build-time note in shipped data forever.
- * The tree is already read by this module for the same reason
- * ({@link noteFilesById}) — to place a finding where its author can fix it.
- *
- * **A declaration is keyed by document subtype, not by note type.** The address
- * space is the one consumers resolve against, and it is spelled in compiled
- * documents: `hm3` compiles a `projectile` note into a `missilegear` item,
- * so that is the address a rename of it moves. {@link referencedSubtype} is the
- * function that already answers this for a being's embedded `(type, shortcode)`
- * references, so both sides read the same rule rather than a second copy of it.
- *
- * **An entry is emitted for every system that maps the type**, whether or not
- * the note declares that system's block. Over-emitting is inert — the diff uses
- * an entry only when the baseline published the old address *and* this build
- * publishes the new one, and a system the note does not compile for satisfies
- * neither — while asking which blocks a note declares would put a second,
- * subtly different answer to that question in a third place.
- *
- * **First claim wins on a collision.** Two notes naming one predecessor is a
- * contradiction — an address has one successor — and it is reported as an error
- * by `engine/content-lint.mjs`, where both notes are in hand and can both be
- * named. Picking one here keeps this a map; it is not a resolution, and nothing
- * rests on which one it picked.
- *
- * @param {string} contentBase - Root of the content tree.
- * @param {object} opts
- * @param {readonly string[]} [opts.skipDirectories] - The corpus scope. Stated
- *   by the caller, never defaulted — see {@link addressCorpus}.
- * @param {readonly object[]} [opts.maps] - The document-subtype maps.
- * @param {object} [opts.config] - The resolved build configuration.
- * @param {readonly object[]} [opts.records] - Index records the caller already
- *   derived, shared with {@link noteFilesById} so one command reads one corpus.
- * @param {object[]} [opts.problems] - Collects the notes the index cannot
- *   record, so one of them does not abort the diff before it reports.
- * @returns {Map<string, {to: string, file: string, shortcode: string}>} Old
- *   address → the address the declaring note publishes at now, and that note.
- */
-export function declaredPredecessors(contentBase: string, { skipDirectories, maps, config, records, problems }?: {
-    skipDirectories?: readonly string[] | undefined;
-    maps?: readonly object[] | undefined;
-    config?: object | undefined;
-    records?: readonly object[] | undefined;
-    problems?: object[] | undefined;
-}): Map<string, {
-    to: string;
-    file: string;
-    shortcode: string;
-}>;
 /**
  * Every address the baseline published that this build does not.
  *
- * An address that merely *arrived* is not a finding: adding one breaks nobody.
- * The arrivals are read only to answer the one question that matters about a
- * departure — is the document still here under another name?
+ * An address that arrived is not a finding. A departed address is a rename
+ * only when its document id appears at another current address; otherwise it
+ * is a withdrawal.
  *
  * @param {Map<string, object>} baseline - The released address space.
  * @param {Map<string, object>} current - This build's address space.
  * @param {object} opts
- * @param {string} opts.baseline - What the baseline is, for the message —
- *   conventionally `<package>@<version>`.
- * @param {Map<string, {to: string, file: string}>} [opts.predecessors] - The
- *   declared renames, from {@link declaredPredecessors}. Omitted, the diff
- *   falls back to the id join alone and reports an unpinned rename as a
- *   withdrawal, which is what it did before.
- * @returns {Array<object>} One finding per departed address, in address order
- *   so two runs read the same. `kind` is `"renamed"` (with `to`, and `declared`
- *   when it was the note's word rather than an id match) or `"withdrawn"`.
+ * @param {string} opts.baseline - What the baseline is, for the message.
+ * @returns {Array<object>} One finding per departed address, in address order.
  */
-export function diffItemAddresses(baseline: Map<string, object>, current: Map<string, object>, { baseline: label, predecessors }: {
+export function diffItemAddresses(baseline: Map<string, object>, current: Map<string, object>, { baseline: label }: {
     baseline: string;
-    predecessors?: Map<string, {
-        to: string;
-        file: string;
-    }> | undefined;
 }): Array<object>;
 /**
- * Every content note in a tree, indexed by the document id it authors.
+ * Every content note in a tree, indexed by the document id it compiles under.
  *
  * The address space is read from compiled output because that is what actually
  * ships; the tree is read only to place a finding somewhere a reader can open
@@ -135,7 +67,7 @@ export function diffItemAddresses(baseline: Map<string, object>, current: Map<st
  * @param {object} [opts.config] - The resolved build configuration, which the
  *   id is derived against. See {@link addressCorpus} for why that matters.
  * @param {readonly object[]} [opts.records] - Index records the caller already
- *   derived, shared with {@link declaredPredecessors}.
+ *   derived by the caller.
  * @param {object[]} [opts.problems] - Collects the notes the index cannot
  *   record, so one of them does not abort the diff before it reports.
  * @returns {Map<string, string>} Document id → the note's absolute path.
@@ -149,22 +81,13 @@ export function noteFilesById(contentBase: string, { skipDirectories, config, re
 /**
  * Where to send the reader for one finding.
  *
- * A rename is fixed in the note that made it, so a finding whose id is still in
- * this tree is reported at that note's `shortcode:` line — the line the author
- * just edited. A withdrawal has no such note by definition, so it degrades to
- * the baseline document, which is the only artefact left that records the
- * address existing. When neither is readable the position is **dropped**, never
- * defaulted to `1:1`.
- *
- * A **declared** rename knows its note without any lookup — the declaration is
- * how it was found — and is reported at the `renamedFrom:` line rather than the
- * `shortcode:` line, because that is the line the finding is about and the one
- * the author deletes once the declaration has done its work.
+ * A matched document is located at its current `shortcode:` line. A withdrawal
+ * is located in the baseline artifact, the remaining evidence for its address.
+ * When neither source has a usable position, the location is dropped.
  *
  * @param {object} finding - One finding from {@link diffItemAddresses}.
  * @param {Map<string, string>} noteFiles - From {@link noteFilesById}.
- * @returns {{file?: string, line?: number, column?: number}} Spreadable
- *   position fields for {@link formatDiagnostic}.
+ * @returns {{file?: string, line?: number, column?: number}} Position fields.
  */
 export function locateAddressFinding(finding: object, noteFiles: Map<string, string>): {
     file?: string;
@@ -174,21 +97,9 @@ export function locateAddressFinding(finding: object, noteFiles: Map<string, str
 /**
  * What one finding says, without a locator or a severity.
  *
- * The rename message names the identity it matched on, because that is what
- * separates this from a spelling suggestion: the reader can check the id in
- * both artefacts. The withdrawal message names no successor, because none is
- * known — and says so, rather than leaving the reader to wonder whether one was
- * looked for.
- *
- * **A declared rename says it is declared**. The two claims are not
- * equally checkable: an id match is a fact in the artefacts, while a
- * declaration is an author's word, and a reader deciding whether to trust the
- * successor needs to know which one they have. Saying "the same document" of a
- * declared rename would spend the id match's credibility on it.
- *
- * The consequence sentence is the same for both, because it is the same
- * consequence: the old address stops resolving either way, and that is what
- * the reader has to act on.
+ * A matched document names the address where it now appears. A withdrawal
+ * names no successor because the current build publishes no document with
+ * that identity.
  *
  * @param {object} finding - One finding from {@link diffItemAddresses}.
  * @returns {string} The message.

package/types/engine/art-fields.d.mts

@@ -142,14 +142,12 @@ export function artPathname(index: object, value: unknown, defaultType: string,
     type?: string;
 };
 /**
- * The default art address a being's own tags choose, or `null`.
+ * The default art address a being's subtype chooses, or `null`.
  *
- * `character` means a **person**, not a human, and `creature` everything else;
- * a being carries exactly one of the two, which is what makes the choice a
- * lookup rather than a precedence rule.
+ * An NPC and a character use person art; a creature uses creature art.
  *
  * @param {object} fm - The note's frontmatter.
- * @returns {string|null} The address, or `null` for a note carrying neither tag.
+ * @returns {string|null} The address, or `null` when no subtype selects one.
  */
 export function beingDefaultArt(fm: object): string | null;
 /**
@@ -181,7 +179,7 @@ export function unresolvedArtMessage(key: string, value: unknown): string;
 export function unacceptedArtMessage(key: string, value: unknown, type: string, accepts: Iterable<string>): string;
 export { ART_SLOTS } from "./art-slots.mjs";
 /**
- * The art a being falls back to, by the kind it is tagged.
+ * The art a being falls back to, by its subtype.
  *
  * Both files ship in `sohl`, under `assets/icons/other/`, and both are named
  * here as addresses rather than as paths for the reason every art reference is:
@@ -189,8 +187,8 @@ export { ART_SLOTS } from "./art-slots.mjs";
  * package borrowing the default gets the same file the system ships.
  *
  * **Only the compiler can choose between them**, because only the compiler
- * reads the note's tags. A schema default is the last resort beneath this one,
- * and covers a world document created by hand, which no note describes.
+ * reads the note's subtype. A schema default is the last resort beneath this
+ * one, and covers a world document created by hand, which no note describes.
  *
  * @type {Readonly<Record<string, string>>}
  */

package/types/engine/frontmatter-lint.d.mts

@@ -12,6 +12,20 @@
  * @returns {boolean} Whether it is acceptable.
  */
 export function matchesKind(value: unknown, kind: string, context?: object): boolean;
+/**
+ * Resolve system-block addresses declared by the system's own field schema.
+ * @param {object} note - A note from the link index.
+ * @param {object} opts
+ * @param {object} opts.index - The address index.
+ * @param {Record<string, readonly object[]>} [opts.schemas] - Note schemas.
+ * @param {Readonly<Record<string, object>>} [opts.systems] - Declared system blocks.
+ * @returns {object[]} Located findings for unresolved addresses.
+ */
+export function systemAddressFindings(note: object, { index, schemas, systems }?: {
+    index: object;
+    schemas?: Record<string, readonly object[]> | undefined;
+    systems?: Readonly<Record<string, object>> | undefined;
+}): object[];
 /**
  * Check one note against its type's schema.
  *

package/types/engine/helpers.d.mts

@@ -14,7 +14,8 @@ export function renderFoundryMarkdown(body: any, captions: any, footnoteNumbers:
  * @param {string} filePath - Markdown file to read.
  * @param {{addressContext?: object}} [opts] - Address defaults for decoded fields.
  * @returns {{frontmatter: object|null, body: string, description: string,
- *   bodyLine?: number, bodyColumn?: number}} Parsed note and body position.
+ *   bodyLine?: number, bodyColumn?: number, parseError?: {message: string,
+ *   line?: number, column?: number}}} Parsed note and body position.
  */
 export function parseMarkdownFile(filePath: string, { addressContext }?: {
     addressContext?: object;
@@ -24,6 +25,11 @@ export function parseMarkdownFile(filePath: string, { addressContext }?: {
     description: string;
     bodyLine?: number;
     bodyColumn?: number;
+    parseError?: {
+        message: string;
+        line?: number;
+        column?: number;
+    };
 };
 /**
  * Refuse a corpus read whose scope its caller did not state.
@@ -98,6 +104,11 @@ export function walkMarkdownTree(rootDir: string, { skipDirectories, addressCont
     description: string;
     bodyLine?: number;
     bodyColumn?: number;
+    parseError?: {
+        message: string;
+        line?: number;
+        column?: number;
+    };
 }, void, unknown>;
 /**
  * The template priority a note states, for a system that treats an unstated one

package/types/engine/index.d.mts

@@ -47,7 +47,6 @@ export * as infobox from "./infobox.mjs";
 export * as infoboxRegistry from "./infobox-registry.mjs";
 export * as infoboxRender from "./infobox-render.mjs";
 export * as noteIds from "./note-ids.mjs";
-export * as noteRenames from "./note-renames.mjs";
 export * as metadataIndex from "./metadata-index.mjs";
 export * as foundryEntries from "./foundry-entries.mjs";
 export * as contentIndex from "./content-index.mjs";

package/types/engine/infobox.d.mts

@@ -146,8 +146,9 @@ export function linkValue(ref: unknown, resolve: (ref: unknown, hint?: object) =
  *
  * The rows are {@link NOTE_VOCABULARY}'s declaration for the type, in its
  * order, minus what {@link NOTE_FIELD_PRESENTATION} withholds and minus every
- * field the note left empty. A type that declares no `data:` fields still gets
- * the box, because `Name` is a fact about every note.
+ * field the note left empty. A being's top-level `subType` adds its profile
+ * type. A type that declares no `data:` fields still gets the box, because
+ * `Name` is a fact about every note.
  *
  * @param {object} fm - The note's frontmatter.
  * @param {object} [options] - Options.

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

@@ -233,15 +233,6 @@ export const DECLARED_TAGS: Readonly<{
         types: string[];
         tags: readonly string[];
     }>;
-    /**
-     * What kind of being this is — a person, or one of the beasts and made
-     * things. A being is one or the other, so the group is a slot.
-     */
-    beingKind: Readonly<{
-        types: string[];
-        exclusive: "kind";
-        tags: readonly string[];
-    }>;
     /** A note's working state, which any note may carry. */
     state: Readonly<{
         types: null;

package/types/engine/subtype-registry.d.mts

@@ -1,7 +1,7 @@
 /**
  * The map one system ships, by its id.
  *
- * @param {string|undefined} system - The system id (`"sohl"`, `"hm3"`).
+ * @param {string|undefined} system - The system id.
  * @returns {import("./document-subtypes.mjs").DocumentSubtypeMap|undefined} Its
  *   map, or `undefined` where this toolchain ships none for it.
  */
@@ -29,10 +29,6 @@ export function schemaSubtypeOf(system: string | undefined, type: string): strin
 /**
  * The note-type → document-subtype maps this toolchain ships.
  *
- * Two, since `hm3/` landed — and it joined this list rather than the
- * claim table growing a second copy of the same fact, which is what the list
- * was for.
- *
  * The union is what makes the vocabulary wider than any one repository's
  * configuration: `armorlocation` is a real content type because HM3 maps it,
  * however a given repository is configured, so a tree full of them is a
@@ -71,7 +67,7 @@ export const KNOWN_DOCUMENT_SUBTYPE_MAPS: readonly import("./document-subtypes.m
  */
 export const DEFAULT_DOCUMENT_SUBTYPES: import("./document-subtypes.mjs").DocumentSubtypeMap;
 /**
- * Every system this toolchain ships a map for, by id.
+ * Every system identifier with declared system-specific document types.
  *
  * Derived from {@link KNOWN_DOCUMENT_SUBTYPE_MAPS}, so registering a map is the
  * whole of adding a system to every reader that asks "which systems are there?"

package/types/engine/systems.d.mts

@@ -28,8 +28,8 @@ export function isSystemSegment(value: unknown): boolean;
  *
  * The nullish case is called out by name because it is the likely mistake and
  * the least legible failure: a YAML `null`, a `~`, or a key written with no
- * value at all reaches here as `undefined`, and "expected one of sohl, hm3,
- * none" would leave a reader hunting for the value they cannot see.
+ * value at all reaches here as `undefined`, and a list of accepted values
+ * would leave a reader hunting for the value they cannot see.
  *
  * @param {unknown} value - The offending value.
  * @param {string} [where] - What carried it, for the message — a note path, a
@@ -83,11 +83,11 @@ export const NO_SYSTEM: string;
 /** The Address segment for a note's readable content. */
 export const NOTE_SYSTEM: "note";
 /**
- * Every game system this toolchain compiles for.
+ * Every game system identifier this toolchain recognizes.
  *
- * The registry, and the only place the list is written down. Adding a system
- * is an edit to this set plus the map and compilers that make it real — a data
- * change, not a search for every place a name was spelled.
+ * The registry, and the only place the list is written down. A recognized id
+ * can have no system-specific document types; adding one of those requires a
+ * subtype map and compiler as well.
  *
  * `none` is **not** a member: it marks the absence of a system, and a caller
  * asking "is this a system" and a caller asking "is this a well-formed

package/engine/note-renames.mjs

@@ -1,134 +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
- */
-
-/**
- * The shortcodes a note declares it used to be published under.
- *
- * A package's `(type, shortcode)` addresses are a published interface, and
- * `addresses diff` reports what a build stopped publishing — telling a
- * **rename** from a **withdrawal** by matching document ids across two
- * releases. The property that rested on is gone: an id is derived from
- * the canonical address, which carries the shortcode, so renaming a shortcode
- * moves the id too: both sides of the join move together, the match finds
- * nothing, and a rename is reported as a withdrawal with no successor named.
- *
- * **The remaining lever needed foresight, which is the wrong thing to ask for.**
- * An authored `id:` still wins, and pinning one does keep a document's identity
- * across a rename — but it has to be written *before* the rename, by an author
- * who does not yet know they will make one. An author who has just renamed a
- * shortcode knows exactly what the old one was, and that is the only moment
- * anyone does.
- *
- * So a note states it:
- *
- * ```yaml
- * type: weapongear
- * shortcode: Taburi
- * renamedFrom: Tabri
- * ```
- *
- * **A declaration is an assertion, not a match, and the diagnostic says which
- * it had.** That distinction is the whole ethos of `address-diff.mjs`: it
- * refuses to guess a successor from a similar-looking string, because a wrong
- * one sends the reader to the wrong fix. An author's declaration is neither a
- * guess nor an identity match — it is testimony from the one party that knows —
- * so it is used, attributed, and never silently blended with an id match.
- *
- * **It is a list, because renames chain.** The diff is release-to-release and a
- * shortcode may be renamed more than once between two releases; a baseline
- * several releases back published a name two renames ago. A single value would
- * report that as a withdrawal again, which is the bug this closes.
- *
- * **It is transient.** Once every baseline a build is compared against post-dates
- * the rename, the declaration has nothing left to say and may be deleted. That
- * is the difference from an `id:` pin, which is permanent, opaque, and a second
- * identity for a thing that already has one.
- *
- * **It is one key per note, at the top level, however many systems the note
- * compiles into.** A shortcode is the note's, not a system block's: a note
- * carrying `sohl:` and `hm3:` blocks compiles into two documents that share one
- * shortcode, so a rename moves both and one declaration covers both.
- *
- * This module reads the key and says nothing about whether the values are
- * *sound* — that a value is a well-formed shortcode, is not the note's own, and
- * does not name an address some live note still publishes are cross-note
- * questions, and `engine/content-lint.mjs` owns them. Composing a value into an
- * address key is likewise not here: the diff defines that space and spells the
- * key once, in `engine/address-diff.mjs`.
- *
- * @module
- */
-
-/**
- * The `renamedFrom:` entries a note authors, exactly as authored.
- *
- * Scalar or list, because one predecessor is the overwhelmingly common case and
- * requiring `- ` on it would be friction with nothing behind it; both normalize
- * here so no reader has to ask which form it got.
- *
- * Entries are returned **unvalidated** — a number, a nested list, a blank
- * string all come back as they were written. The lint needs to see them to
- * report them, and a reader that quietly dropped them would report a correct
- * tree clean while a typo silently did nothing.
- *
- * @param {object|null|undefined} fm - Parsed frontmatter.
- * @returns {readonly unknown[]} The authored entries, in authored order; empty
- *   when the note declares none.
- */
-export function renamedFromEntries(fm) {
-    if (!fm || typeof fm !== "object") return [];
-    const raw = /** @type {{renamedFrom?: unknown}} */ (fm).renamedFrom;
-    if (raw == null) return [];
-    return Array.isArray(raw) ? raw : [raw];
-}
-
-/**
- * The well-formed shortcodes among a note's `renamedFrom:` entries.
- *
- * Trimmed, de-duplicated, and in authored order. Anything that is not a
- * non-blank string is skipped rather than coerced: it is reported by the lint,
- * and a diff that guessed at what a number meant would claim a rename nobody
- * declared.
- *
- * De-duplicating here rather than leaving it to callers is not tidiness — the
- * predecessor index is a map, so a repeated entry would otherwise be indexed
- * twice and the second write would look like a conflicting claim.
- *
- * @param {object|null|undefined} fm - Parsed frontmatter.
- * @returns {string[]} The declared predecessor shortcodes.
- */
-export function renamedFrom(fm) {
-    const seen = new Set();
-    for (const entry of renamedFromEntries(fm)) {
-        if (typeof entry !== "string") continue;
-        const trimmed = entry.trim();
-        if (trimmed) seen.add(trimmed);
-    }
-    return [...seen];
-}
-
-/**
- * Whether a note declares the key at all, however malformed its value.
- *
- * Separate from {@link renamedFrom} returning nothing, because the two mean
- * opposite things to a lint: a note declaring no key is silent and correct,
- * while one declaring `renamedFrom: []` — or a single blank string — has said
- * something that does nothing, which is worth a word.
- *
- * @param {object|null|undefined} fm - Parsed frontmatter.
- * @returns {boolean} `true` when the key is present and not null.
- */
-export function declaresRenamedFrom(fm) {
-    if (!fm || typeof fm !== "object") return false;
-    return /** @type {{renamedFrom?: unknown}} */ (fm).renamedFrom != null;
-}