@heroiclands/package-build 23.1.1 → 23.2.1

package/engine/frontmatter.mjs

@@ -83,63 +83,39 @@ export function sohlField(fm, key, defaultValue = undefined) {
  * `relations` and a projectile's impact die — because each validates a *shape
  * spread over several keys* rather than coercing one scalar.
  *
- * That was equivalent while every note authored inside the block, and stopped
- * being so once a note may author at `sohl.system.<to>` instead: {@link
- * sohlField} sees `sohl.<key>` and the top level, never inside `sohl.system`.
- * So those five read as unset and shipped their empty value — a missing
- * `subType` is a thrown build error, and the other four ship empty in silence,
- * which is the failure class the passthrough exists to prevent.
+ * {@link sohlField} sees `sohl.<key>` and the top level, never inside
+ * `sohl.system`, so this reads the destination first: a note may author at
+ * `sohl.system.<to>`, and a reader that could not see it would ship the
+ * field's empty value in silence.
  *
  * The **destination wins**, matching every other field's resolution order.
  *
- * `legacyKey` is for the one pair whose two positions are spelled differently:
- * a projectile authors `impact.die` and stores `impactBase.die`, so the reader
- * has to be told both. It is the same split `FieldSpec.name`/`legacyKey` makes,
- * for the same reason — one name cannot key two positions.
+ * `name` is for the one pair whose two positions are spelled differently: a
+ * projectile authors `impact.die` and stores `impactBase.die`, so the reader
+ * has to be told both.
  *
- * `shared` is the field's declared shared source, and it completes the order the
- * three other positions are two thirds of. A field whose source is a path into
- * `data:` is authored there by the specification's own mapping tables, and a
- * reader that knew the destination, the block and the top level alone skipped
- * straight past the container: every authored value read as unset, and the
- * document shipped the field's default with nothing said. It sits **between**
- * the block and the top level, exactly where
- * {@link module:engine/system-block.resolveFieldValue} puts it — the block is the
- * position a tree still writes and wins while it does, and the bare top-level
- * key is the spelling `data:` gathered the fact off.
+ * `shared` is the field's declared shared source when it is a path into
+ * `data:`. Such a field is authored in that container and nowhere else, so the
+ * block and the top level are not consulted.
  *
  * @param {object} fm - The note's frontmatter.
  * @param {string} to - The key at the destination, dotted for a nested one.
  * @param {any} [defaultValue] - What an unauthored field reads as.
  * @param {object} [options] - Options.
- * @param {string} [options.legacyKey] - The key the block still carries, when
- *   it is not spelled `to`. Defaults to `to`.
+ * @param {string} [options.name] - The key the block carries, when it is not
+ *   spelled `to`. Defaults to `to`.
  * @param {string} [options.shared] - The field's declared shared source, when it
- *   is a path into a container (`data.relations`). Omitted by a field whose
- *   shared position is the note's top level, which `sohlField` already reads.
+ *   is a path into a container (`data.relations`).
  * @returns {any} The value.
  */
-export function sohlSystemField(fm, to, defaultValue = undefined, { legacyKey = to, shared } = {}) {
+export function sohlSystemField(fm, to, defaultValue = undefined, { name = to, shared } = {}) {
     const system = fm?.sohl?.system;
     if (system && typeof system === "object" && !Array.isArray(system)) {
         const found = getFrontmatter(system, to, undefined);
         if (found !== undefined) return found;
     }
-    if (shared !== undefined) {
-        const block = fm?.sohl;
-        const inBlock =
-            block && typeof block === "object" ?
-                getFrontmatter(block, legacyKey, undefined)
-            :   undefined;
-        // Consulted only where the block does not carry the key, so step 2 keeps
-        // winning; `sohlField` below then reads the block and the retiring
-        // top-level spelling exactly as it always has.
-        if (inBlock === undefined) {
-            const container = getFrontmatter(fm, shared, undefined);
-            if (container !== undefined) return container;
-        }
-    }
-    return sohlField(fm, legacyKey, defaultValue);
+    if (shared !== undefined) return getFrontmatter(fm, shared, defaultValue);
+    return sohlField(fm, name, defaultValue);
 }
 
 /**
@@ -184,9 +160,6 @@ function readMapEntries(fm, key, { shared } = {}) {
  * so absent frontmatter must resolve to `null` — coercing it to `0` would ship
  * every item as an uncapped charge-user.
  *
- * A legacy `usesCharges` flag in authored frontmatter is ignored: it was inert
- * and has been dropped from the schema.
- *
  * @param {object} fm - The item frontmatter.
  * @returns {{value: number|null, max: number|null}} The persisted charges block.
  */
@@ -249,7 +222,7 @@ export function resolveSkillAptitudes(fm, ctx = "item") {
 }
 
 /**
- * Resolve an affiliation's `relation` map — the shortcode of another
+ * Resolve an affiliation's `relations` map — the shortcode of another
  * affiliation → this one's standing toward it.
  *
  * An unrecognized standing would fail the schema's `choices` validation at load
@@ -266,18 +239,7 @@ export function resolveSkillAptitudes(fm, ctx = "item") {
  * @throws {Error} When the map is malformed or names an unknown standing.
  */
 export function resolveRelation(fm, ctx = "item") {
-    // `relations` is the field's name; `relation` is the retired spelling, read
-    // underneath it so a tree converts on its own schedule. The
-    // current name wins wherever a note writes both, and the lint reports the
-    // old one through {@link RETIRED_FIELD_ALIASES}.
-    // Probed at the destination too: a note that has moved to
-    // `sohl.system.relations` carries the current spelling, and a probe that
-    // could not see it would fall through to the retired one and read `{}`.
-    // Each spelling is probed at all four of its positions, the `data:` source
-    // the specification names included, so a retirement and a container move are
-    // independent of each other.
-    const current = sohlSystemField(fm, "relations", undefined, { shared: "data.relations" });
-    const key = current == null ? "relation" : "relations";
+    const key = "relations";
     const entries = readMapEntries(fm, key, { shared: `data.${key}` });
     if (entries === null) {
         throw new Error(`${ctx}: ${key} must be a map of shortcode → standing`);
@@ -362,20 +324,8 @@ export function parseValueDesc(raw) {
  *
  * `data.packFolder` is a folder note's **address**
  * (`folder-poisonsandtoxins`), resolved through the address index the whole
- * build shares. The `folder:` Foundry-id spelling this function once read
- * beside it, and the per-pack `*-folders.yaml` that id was resolved against,
- * are retired together — a note declaring `folder:` is refused by
- * {@link module:engine/folder-notes.assertNoDeclaredFolder} rather than
- * reaching here, so there is no second source for a value to come from.
- *
- * **`packFolder` was a path for one release** (`Possessions/Misc_Gear/Cooking`)
- * and is an address now. A path encoded the hierarchy *in the value*, so
- * reparenting a folder made every note naming it wrong — a structural edit
- * became a corpus-wide rewrite. An address is stable under reparenting, which
- * is exactly why a note is addressed by `(type, shortcode)` and never by
- * `file.path`. The path form is **removed rather than deprecated**: it had no
- * authors to migrate, which is the whole reason the change was cheap enough to
- * make.
+ * build shares. An address is stable under reparenting, which is exactly why a
+ * note is addressed by `(type, shortcode)` and never by `file.path`.
  *
  * @param {object|null|undefined} fm - Parsed frontmatter.
  * @returns {{value: string|null, isAddress: boolean}} The authored value, and

package/engine/generate.mjs

@@ -28,15 +28,14 @@
  * anywhere**. A folder is a note like any other, named by `packFolder`
  * — its address — and it materialises in every pack that holds a document
  * naming it, its ancestors with it. So no pack loads a folder list, and
- * two packs can no longer disagree about a folder they both hold.
+ * two packs cannot disagree about a folder they both hold.
  *
  * **The order the passes run in is derived, not declared** — see
  * {@link orderPassesByDependency}. The declared list is the manifest's `packs`
  * array as well, so it is ordered for a reader; a pass that reads another's
  * output states that on its compiler and is scheduled after it.
  *
- * This replaces the retired `packs:export` (vault → committed `_source/`); the
- * HeroicLands vault is no longer a build input for SoHL content.
+ * The HeroicLands vault is not a build input for SoHL content.
  */
 
 import { noteAddressContext } from "./note-addresses.mjs";
@@ -73,7 +72,7 @@ import { routerFor } from "./pack-router.mjs";
 import { NEVER_PACKED_TYPES, unclaimedNoteFindings } from "./note-claims.mjs";
 // Which document a content type compiles into, so the art declaration below is
 // answered from the same routing the compile uses.
-import { RETIRED_TYPES, currentType, packForType } from "./ids.mjs";
+import { packForType } from "./ids.mjs";
 import { contentPackage } from "./content-package.mjs";
 
 /**
@@ -230,22 +229,22 @@ export function compilerFor(docType, system = null) {
  * @param {string} type - The note's content type.
  * @returns {{document: string|null, art: readonly string[]}|null} What the type
  *   compiles into and the art it carries there, or `null` where no claim can be
- *   made — a retired type, which is reported as retired instead.
+ *   made.
  */
 export function emittedArtFor(type) {
     const name = String(type ?? "");
-    if (!name || Object.hasOwn(RETIRED_TYPES, name)) return null;
+    if (!name) return null;
 
     // A homepage compiles into a *page*, not a compendium document, so nothing
     // it authors reaches one. It is the one type whose absence from every pack
     // is the intended state (`NEVER_PACKED_TYPES`).
-    if (NEVER_PACKED_TYPES.has(currentType(name))) return { document: null, art: [] };
+    if (NEVER_PACKED_TYPES.has(name)) return { document: null, art: [] };
 
     // A folder reaches a pack by a route of its own — it materialises in every
     // pack holding a document that references it — so `packForType` has no
     // answer for it and no compiler class writes it. `folderDocument` does, and
     // a Foundry `Folder` has no artwork at all.
-    if (currentType(name) === FOLDER_TYPE) return { document: "Folder", art: [] };
+    if (name === FOLDER_TYPE) return { document: "Folder", art: [] };
 
     const { docType } = packForType(name);
     const passes = [
@@ -516,11 +515,8 @@ async function generatePack(
     /**
      * The Foundry folder id a note names, by its folder note's address.
      *
-     * There is one spelling. `packFolder` names a folder **note**, resolved
-     * through the address index shared by the whole build; the `folder:`
-     * Foundry-id spelling and the per-pack `*-folders.yaml` it resolved
-     * against are retired together, so there is no second source left
-     * for a value to come from.
+     * `packFolder` names a folder **note**, resolved through the address index
+     * shared by the whole build.
      *
      * @param {string|null|undefined} value - As authored.
      * @returns {string|null} The folder id, or `null` for an absent value.
@@ -799,8 +795,7 @@ export async function generatePacksJson({ only, config = loadPackConfig() } = {}
         emitDiagnostic(finding);
 
     // A note whose `type:` no configured pack claims compiles into nothing, and
-    // used to say nothing — no pass got far enough to reject it, so the
-    // silence had no owner. Asked once, of the whole configuration, because
+    // no pass gets far enough to reject it, so the silence has no owner. Asked once, of the whole configuration, because
     // that is the only place it can be answered: a per-pass check would report
     // every type a system deliberately does not map, which is exactly the
     // silence the rule requires. Independent of `only`, since it is a fact about the

package/engine/heading-attributes.mjs

@@ -1,4 +1,15 @@
-/* SPDX-License-Identifier: GPL-3.0-or-later */
+/*
+ * 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 braced attribute block a heading may end with, read once.

package/engine/helpers.mjs

@@ -303,7 +303,7 @@ export function parseMarkdownFile(filePath, { addressContext } = {}) {
  *
  * The rule in one place, so every reader of the tree refuses the same
  * way and says so in the same words. It is shared rather than repeated because
- * the corpus is no longer read only by {@link walkMarkdownTree}: a pass that
+ * the corpus is read by more than {@link walkMarkdownTree}: a pass that
  * reads the content index instead is making the identical claim about which
  * files it is looking at, and must be held to the identical requirement — a
  * scope that quietly defaulted there would reintroduce exactly the second
@@ -423,68 +423,45 @@ export function* walkMarkdownTree(rootDir, { skipDirectories, addressContext } =
  * block, in the order they answer — and whichever of them the note actually
  * wrote.
  *
- * Three places, in the order the migration runs. The specification calls this
- * `data.templatePriority`; `sohl-thalorna` already writes it there on 941
- * notes, beside the `archetype` the build reads — so a tree that has authored
- * forward is read from the key it authored, and only then does the retiring
- * spelling answer.
+ * Three places: the specification calls this `data.templatePriority`, and the
+ * system block and the note's top level answer after it.
  *
  * **The block is a parameter because the value is shared, not per-system.** One
  * `data.templatePriority` is the note's statement that it is a template; SoHL
  * records it as `system.templatePriority` and HM3 as `flags.hm3.templatePriority`.
- * The legacy in-block position is therefore read from *the block being compiled*
+ * The in-block position is therefore read from *the block being compiled*
  * rather than always from `sohl:`, so an HM3-only note is not asked to author a
  * SoHL block to be read.
  *
  * @param {object} fm     Parsed frontmatter.
  * @param {string} block  The system block being compiled.
- * @returns {{found: [object, string]|undefined, retiring: [object, string]|undefined,
- *   NEW: string, OLD: string}} The answering position, the retiring spelling's
- *   position if the note also carries it, and the two key names.
+ * @returns {{found: [object, string]|undefined, KEY: string}} The answering
+ *   position and the key name.
  */
 function findTemplatePriority(fm, block) {
     const inBlock =
         fm != null && typeof fm[block] === "object" && fm[block] !== null ? fm[block] : null;
     const data = fm != null && typeof fm.data === "object" && fm.data !== null ? fm.data : null;
 
-    const NEW = "templatePriority";
-    const OLD = "archetype";
+    const KEY = "templatePriority";
     const sources = /** @type {[object|null, string][]} */ ([
-        [data, NEW],
-        [inBlock, NEW],
-        [fm, NEW],
-        [inBlock, OLD],
-        [fm, OLD],
+        [data, KEY],
+        [inBlock, KEY],
+        [fm, KEY],
     ]);
     const found = sources.find(([where, key]) => where != null && key in where);
-    // A note part-way through the rename may carry both spellings, and they may
-    // *disagree*: 145 of `sohl-thalorna`'s 941 dual-spelled notes say
-    // `templatePriority: null` where `archetype: 0` says the opposite — "not a
-    // template" against "a template at priority 0". Preferring the new key
-    // silently would flip those documents, and preferring the old would ignore
-    // what an author wrote most recently. Neither is a decision this function
-    // gets to make quietly, so a contradiction is refused and named.
-    const retiring = sources
-        .slice(sources.findIndex(([, key]) => key === OLD))
-        .find(([where, key]) => where != null && key in where);
-    return {
-        found: /** @type {[object, string]|undefined} */ (found),
-        retiring: /** @type {[object, string]|undefined} */ (retiring),
-        NEW,
-        OLD,
-    };
+    return { found: /** @type {[object, string]|undefined} */ (found), KEY };
 }
 
 /**
  * The template priority a note states, for a system that treats an unstated one
  * as "not a template" rather than as an authoring error.
  *
- * Reads exactly the positions {@link resolveTemplatePriority} reads, including
- * the retiring `archetype` spelling, and refuses the same contradiction — so
- * the two systems cannot disagree about what a note said. It differs only in
- * what silence means: SoHL requires the statement, while HM3 keeps the value in
- * a flag it simply omits, so there is no tri-state for an absent value to
- * corrupt and nothing to demand.
+ * Reads exactly the positions {@link resolveTemplatePriority} reads, so the two
+ * systems cannot disagree about what a note said. It differs only in what
+ * silence means: SoHL requires the statement, while HM3 keeps the value in a
+ * flag it simply omits, so there is no tri-state for an absent value to corrupt
+ * and nothing to demand.
  *
  * @param {object} fm      Parsed frontmatter.
  * @param {string} label   Human-readable context for error messages.
@@ -492,18 +469,9 @@ function findTemplatePriority(fm, block) {
  * @param {string} [options.block="sohl"] The system block being compiled.
  * @returns {number|null}  The priority, or `null` when the note is not a
  *   template or states nothing.
- * @throws {Error} When both spellings are present and disagree.
  */
 export function statedTemplatePriority(fm, label, { block = "sohl" } = {}) {
-    const { found, retiring, NEW, OLD } = findTemplatePriority(fm, block);
-    if (found && retiring && found[1] !== OLD && found[0][found[1]] !== retiring[0][OLD]) {
-        throw new Error(
-            `Conflicting ${NEW} for ${label}: ` +
-                `${NEW} is ${JSON.stringify(found[0][found[1]])} and the retiring ` +
-                `${OLD} is ${JSON.stringify(retiring[0][OLD])}. Both are read and ` +
-                `${NEW} wins, so they must agree — delete ${OLD}, or correct it`,
-        );
-    }
+    const { found } = findTemplatePriority(fm, block);
     if (!found) return null;
     const raw = found[0][found[1]];
     return raw === null || raw === "" || raw === undefined ? null : raw;
@@ -519,31 +487,21 @@ export function statedTemplatePriority(fm, label, { block = "sohl" } = {}) {
  *                silently assumed.
  *
  * Reads the positions {@link findTemplatePriority} lists: `data.templatePriority`
- * first — the specified home — then the system block and the top level, and
- * finally the retiring `archetype` spelling in the same two places.
+ * first — the specified home — then the system block and the top level.
  *
  * @param {object} fm      Parsed frontmatter.
  * @param {string} label   Human-readable context for error messages.
  * @param {object} [options] Options.
  * @param {string} [options.block="sohl"] The system block being compiled.
  * @returns {number|undefined}  The template priority, or `undefined` when null.
- * @throws {Error} When the property is absent, is not a number/null, or both
- *   spellings are present and disagree.
+ * @throws {Error} When the property is absent or is not a number/null.
  */
 export function resolveTemplatePriority(fm, label, { block = "sohl" } = {}) {
-    const { found, retiring, NEW, OLD } = findTemplatePriority(fm, block);
+    const { found, KEY } = findTemplatePriority(fm, block);
 
-    if (found && retiring && found[1] !== OLD && found[0][found[1]] !== retiring[0][OLD]) {
-        throw new Error(
-            `Conflicting ${NEW} for ${label}: ` +
-                `${NEW} is ${JSON.stringify(found[0][found[1]])} and the retiring ` +
-                `${OLD} is ${JSON.stringify(retiring[0][OLD])}. Both are read and ` +
-                `${NEW} wins, so they must agree — delete ${OLD}, or correct it`,
-        );
-    }
     if (!found) {
         throw new Error(
-            `Missing required ${NEW} for ${label} — set a number (this is a template, at that priority) or null (it is not)`,
+            `Missing required ${KEY} for ${label} — set a number (this is a template, at that priority) or null (it is not)`,
         );
     }
     const raw = found[0][found[1]];
@@ -558,7 +516,7 @@ export function resolveTemplatePriority(fm, label, { block = "sohl" } = {}) {
 
 /**
  * The value a document's `system.templatePriority` carries, from the required
- * `templatePriority` frontmatter (`archetype` is the legacy spelling).
+ * `templatePriority` frontmatter.
  *
  * A **schema field**, so the tri-state is written out in full rather than
  * expressed by a key's presence: a number is a template at that priority, and
@@ -602,15 +560,11 @@ export function makeFilename(name, id) {
  * and nothing else, and because the default a caller applies to an unset one is
  * domain-specific — actors default differently from items, and gear differently
  * again — so each compiler owns its default and applies it with **nullish**
- * coalescing: `resolveImg(fm.img) ?? <default>`. Not `||`, which would collapse
- * a deliberate blank back into the default.
+ * coalescing: `resolveImg(fm.img) ?? <default>`.
  *
- * **Two empties, and they mean opposite things.** `null` — or an absent key,
- * which reaches here as `undefined` — means _unset_: the note names no art and
- * the caller's default applies. `""` means _blank on purpose_: the note names
- * no art **and wants none**, so no default may replace it. Both come back
- * distinguishable, `null` and `""` respectively, and neither is invented from
- * the other.
+ * `null` — or an absent key, which reaches here as `undefined` — means _unset_:
+ * the note names no art and the caller's default applies. An empty string is
+ * not a pathname and is refused like any other value that names no file.
  *
  * **`title` does not follow this rule**, and must not be made to. On a
  * `type: affiliation` note `title` is a declared item field with its own
@@ -633,11 +587,11 @@ export function makeFilename(name, id) {
  * @param {string | null | undefined} raw - The pathname from frontmatter.
  * @param {{assetRoot: string|null}} [config] - The resolved build configuration.
  *   Defaults to this repository's.
- * @returns {string | null} the Foundry-relative path; `""` for a deliberate
- *   blank, and `null` when the note names no art at all.
- * @throws {Error} When no Foundry address can be derived — a `documentation`
- *   package, which Foundry installs nothing of, or a pathname naming a package
- *   this build declares no relationship with.
+ * @returns {string | null} the Foundry-relative path, and `null` when the
+ *   note names no art at all.
+ * @throws {Error} When the pathname is empty, or when no Foundry address can
+ *   be derived — a `documentation` package, which Foundry installs nothing of,
+ *   or a pathname naming a package this build declares no relationship with.
  */
 export function resolveImg(raw, config = loadPackConfig()) {
     const forms = resolvePathname(raw, config);
@@ -672,10 +626,8 @@ export function resolveName(fm, defaultValue = "Unnamed") {
  * every v14 build and so left all shipped content permanently eligible for
  * every v14 migration.
  *
- * **Read from the configuration, not from the shipped manifest.** It used to
- * open `paths.packageManifest` and take `compatibility.minimum` out of it,
- * because the configuration had no way to state the fact. Now that it does, the
- * manifest is generated *from* the configuration — so reading it back would be
+ * **Read from the configuration, not from the shipped manifest.** The
+ * manifest is generated *from* the configuration, so reading it back would be
  * a round trip through an artifact that need not exist yet: `build:db` can run
  * before the manifest is written.
  *
@@ -704,9 +656,7 @@ export function supportedCoreVersion(config = loadPackConfig()) {
 /**
  * Default `_stats` block for compiled compendium entries.
  *
- * Every stamped identity is configuration: four compilers used to pass
- * the same frozen `"0.6.0"` literal, and `systemId` / `lastModifiedBy` were
- * written into this function. `coreVersion` alone is *not* configuration — it
+ * Every stamped identity is configuration. `coreVersion` alone is *not* configuration — it
  * comes from {@link supportedCoreVersion}, the configured Foundry floor,
  * so a document never claims to predate the migrations that would rewrite it.
  *
@@ -771,11 +721,9 @@ let cachedDefaultStats;
 /**
  * The `_stats` block every compiler stamps on an entry it emits, built once.
  *
- * Each compiler used to hoist `const STATS = buildStats()` at module scope,
- * which read the shipped package manifest the moment the module was imported —
- * so importing a compiler required a manifest to exist even when nothing was
- * going to be compiled. Deferred to first use and memoised here, the
- * cost and the identity are what they always were; only the moment moved.
+ * Built on first use and memoised, not at module scope: building it reads the
+ * shipped package manifest, and importing a compiler must not require a
+ * manifest to exist when nothing is going to be compiled.
  *
  * @returns {object} The default `_stats` block, shared by every compiler.
  */
@@ -802,7 +750,7 @@ export { makeId } from "./ids.mjs";
 
 // The content-type → document-type map, which decides *which* pack list a
 // note's own document is routed against.
-import { assertTypeNotRetired, packForType } from "./ids.mjs";
+import { packForType } from "./ids.mjs";
 import { collectAnchors } from "./anchors.mjs";
 
 /* ------------------------------------------------------------------------ */
@@ -820,10 +768,7 @@ import { collectAnchors } from "./anchors.mjs";
  * would otherwise address every one of them as the first. A note whose
  * declaration is unroutable is indexed against the conventional name and left
  * for the compile pass to report — the index has no business failing a build,
- * and the pass fails it with a far better message. The one exception is a
- * **retired** content type: this walk is the first to see every
- * note together with its path, and unlike an unroutable declaration there is
- * no pass that would ever claim such a note and report it.
+ * and the pass fails it with a far better message.
  *
  * @param {string} contentBase - Root of the content tree.
  * @param {object} [router] - The pack router. Supplied by the calling pass so
@@ -861,9 +806,8 @@ export function buildContentLinkIndex(
         // A documentation journal is a document this tree emits, not a note in
         // it; the note it documents is indexed here and carries its address.
         if (!isNoteRecord(record)) continue;
-        // The note as its author wrote it — the router, the draft tag and the
-        // retired-type check all read authored fields, and none of them may be
-        // handed the keys the index derived.
+        // The note as its author wrote it — the router and the draft tag read
+        // authored fields, and neither may be handed the keys the index derived.
         const fm = authoredFrontmatter(record);
         const absPath = noteFile(contentBase, record);
         // The id a note's document is filed under: its authored pin, or the
@@ -876,11 +820,6 @@ export function buildContentLinkIndex(
         // no shortcode — which is not an addressable note and has no document
         // to link to.
         if (!fm?.id) continue;
-        // The first walk of every note in the tree, and the only one holding
-        // both the declared type and the file that declares it — so a note
-        // left on a retired type is reported here, by name, rather than
-        // several frames deeper with nothing to go on.
-        assertTypeNotRetired(fm.type, absPath);
         const base = String(record.file.name).replace(/_/g, " ");
         const documentation = recordsByAddress.get(encodeAddresses(record.documentation));
         const noOwnDocument =

package/engine/holdings.mjs

@@ -84,7 +84,7 @@ function referenceKey(value, node, type) {
             type,
             types: new Set([type]),
         },
-        { declared: true, legacyShortcodeCase: true },
+        { declared: true },
     );
     if (tuple.reason || tuple.type !== type) return "";
     return renderAddress({ ...tuple, system: "note" }).toLowerCase();

package/engine/homepage.mjs

@@ -138,10 +138,6 @@ export function isHomepage(fm) {
  * closed vocabulary, so repeating that judgement per type would be a second
  * answer to one question.
  *
- * `aliases` is deliberately not in the class: it is a **retired** field, refused
- * on every note whatever its type, so it is answered there rather than
- * here.
- *
  * @type {ReadonlyMap<string, string>}
  */
 export const HOMEPAGE_REFUSED_FIELDS = Object.freeze(
@@ -184,8 +180,7 @@ export const HOMEPAGE_REFUSED_FIELDS = Object.freeze(
  *
  * Each finding carries the `locator` key to position it at, because the two
  * things that would resolve one — the raw note text and the position helper —
- * belong to the caller. This mirrors {@link module:engine/retired-fields},
- * whose retired-field messages are likewise positioned by whoever reports them.
+ * belong to the caller.
  *
  * **A refused field must be one the note *wrote*.** `resolveNoteId` fills
  * `fm.id` **in place** so every downstream reader sees one derived value —
@@ -364,8 +359,7 @@ export function homepageTitle(fm, config) {
  *
  * The note's own, plus the two derived values every emitted page carries: the
  * resolved `title`, and the package the build derived — no note declares one
- * (`package:` is retired) and the theme's breadcrumb partial reads
- * `.Params.package`.
+ * and the theme's breadcrumb partial reads `.Params.package`.
  *
  * **No `url` and no `slug`.** Hugo publishes the `home` kind at `baseURL`,
  * whose path is already where the package is served, so the page has no
@@ -374,8 +368,7 @@ export function homepageTitle(fm, config) {
  *
  * An authored `aliases` is dropped for the same reason it is on every other
  * page: Hugo reads it as URL redirects, so passing it through would publish a
- * redirect stub at each one. The field is retired and refused before a
- * build reaches here, which makes this a guard rather than a working path.
+ * redirect stub at each one.
  *
  * `related` is derived like every other page's — what links to the homepage
  * is a fact about the rest of the tree — so an authored value is dropped and