@heroiclands/package-build 22.19.0 → 22.21.0

package/engine/frontmatter-lint.mjs

@@ -55,7 +55,12 @@
  */
 
 import { isAddressTuple } from "./address.mjs";
-import { authoredNoteKeys, NOTE_TOP_LEVEL_KEY_SET } from "./note-frontmatter.mjs";
+import {
+    authoredNoteKeys,
+    CHARACTER_NAME_KEYS,
+    NOTE_NAME_KEYS,
+    NOTE_TOP_LEVEL_KEY_SET,
+} from "./note-frontmatter.mjs";
 import { AddressEntries } from "./address-values.mjs";
 import { addressPositions } from "./note-addresses.mjs";
 import { authoredFields, readsLegacyKey } from "./field-spec.mjs";
@@ -78,6 +83,7 @@ import { isAddressSegment } from "./address-charset.mjs";
 // reads is exactly the disagreement to avoid.
 import { DEFAULT_PARENT } from "./folder-notes.mjs";
 import {
+    BEING_ARCHETYPES,
     dataFields,
     declaredTags,
     subTypeCharsetMessage,
@@ -351,6 +357,13 @@ export function matchesKind(value, kind, context = {}) {
             // this answers is whether the value has one of the two shapes the
             // field admits. A list has neither.
             return matchesKind(value, "string") || matchesKind(value, "map");
+        case "list-or-map":
+            // A list, or a map. The two carry different facts rather than
+            // being two spellings of one — a map keyed by Address says what is
+            // true *of* each key, which a list has nowhere to put — so the
+            // field's own check is what reads the entries, and all this
+            // answers is whether the value has one of the two shapes.
+            return Array.isArray(value) || matchesKind(value, "map");
         default:
             return true;
     }
@@ -533,7 +546,13 @@ function checkDataContainer(note, { type, fields, packs, addressContext, index }
 function checkDataReferences(note, field, value, segments, context, index) {
     const checks = [];
     if (field.kind === "address") checks.push({ value, path: [], kind: "address" });
-    if (field.entryKind) {
+    // A `list-or-map` field declares both halves, and each describes one shape:
+    // `entryKind` the list's entries, `keyKind` the map's keys. Reading both of
+    // one value would check a map's standings as if they were Addresses and a
+    // list's indices as if they were its keys.
+    const dual = field.kind === "list-or-map";
+    const written = Array.isArray(value) ? "list" : "map";
+    if (field.entryKind && !(dual && written === "map")) {
         if (Array.isArray(value)) {
             value.forEach((entry, i) =>
                 checks.push({ value: entry, path: [i], kind: field.entryKind }),
@@ -545,7 +564,7 @@ function checkDataReferences(note, field, value, segments, context, index) {
             });
         } else checks.push({ value, path: [], kind: field.entryKind });
     }
-    if (field.keyKind) {
+    if (field.keyKind && !(dual && written === "list")) {
         if (value instanceof AddressEntries) {
             for (const entry of value.entries)
                 checks.push({
@@ -1173,18 +1192,101 @@ export function lintNote(
     const type = String(fm.type ?? "");
     const raw = () => note.raw ?? "";
     const at = (key, literal) => positionInFrontmatter(raw(), key, literal ?? undefined);
-    if (
-        type === "being" &&
-        Array.isArray(fm.data?.archetypes) &&
-        fm.data.archetypes.includes("commoner") &&
-        fm.data.archetypes.length > 1
-    ) {
-        findings.push({
-            file: note.file,
-            ...at("archetypes", "commoner"),
-            severity: "error",
-            message: "`data.archetypes` may contain `commoner` only by itself",
-        });
+    if (type === "being") {
+        const archetypes = fm.data?.archetypes;
+        if (
+            ["character", "npc"].includes(fm.subType) &&
+            (archetypes == null || (Array.isArray(archetypes) && archetypes.length === 0))
+        ) {
+            findings.push({
+                file: note.file,
+                ...positionOfFrontmatterPath(
+                    raw(),
+                    archetypes == null ? ["subType"] : ["data", "archetypes"],
+                ),
+                severity: "error",
+                message: "A character or npc requires at least one `data.archetypes` value",
+            });
+        }
+        if (Array.isArray(archetypes)) {
+            archetypes.forEach((value, i) => {
+                if (!Object.hasOwn(BEING_ARCHETYPES, value)) {
+                    findings.push({
+                        file: note.file,
+                        ...positionOfFrontmatterPath(raw(), ["data", "archetypes", i]),
+                        severity: "error",
+                        message: `Unknown archetype \`${String(value)}\`; use a case-sensitive archetype from the reference`,
+                    });
+                }
+            });
+            const commoner = archetypes.indexOf("commoner");
+            if (commoner !== -1 && archetypes.length > 1) {
+                findings.push({
+                    file: note.file,
+                    ...positionOfFrontmatterPath(raw(), ["data", "archetypes", commoner]),
+                    severity: "error",
+                    message: "`data.archetypes` may contain `commoner` only by itself",
+                });
+            }
+        }
+    }
+    if (Object.hasOwn(fm, "name")) {
+        const name = fm.name;
+        const nameAt = (path) => positionOfFrontmatterPath(raw(), ["name", ...path], { key: true });
+        if (!name || typeof name !== "object" || Array.isArray(name)) {
+            findings.push({
+                file: note.file,
+                ...positionOfFrontmatterPath(raw(), ["name"], { key: true }),
+                severity: "error",
+                message: "`name` must be a map with a nonempty `full` string",
+            });
+        } else {
+            const allowed = new Set(NOTE_NAME_KEYS);
+            if (type === "being" && fm.subType === "character") {
+                for (const key of CHARACTER_NAME_KEYS) allowed.add(key);
+            }
+            for (const key of Object.keys(name)) {
+                if (!allowed.has(key)) {
+                    findings.push({
+                        file: note.file,
+                        ...nameAt([key]),
+                        severity: "error",
+                        message: `\`name.${key}\` is not valid for this note`,
+                    });
+                }
+            }
+            if (typeof name.full !== "string" || !name.full.trim()) {
+                findings.push({
+                    file: note.file,
+                    ...(Object.hasOwn(name, "full") ? nameAt(["full"]) : nameAt([])),
+                    severity: "error",
+                    message: "`name.full` must be a nonempty string",
+                });
+            }
+            if (Object.hasOwn(name, "aliases")) {
+                if (
+                    !Array.isArray(name.aliases) ||
+                    name.aliases.some((alias) => typeof alias !== "string" || !alias.trim())
+                ) {
+                    findings.push({
+                        file: note.file,
+                        ...nameAt(["aliases"]),
+                        severity: "error",
+                        message: "`name.aliases` must be a list of nonempty strings",
+                    });
+                }
+            }
+            for (const key of CHARACTER_NAME_KEYS) {
+                if (!Object.hasOwn(name, key) || !allowed.has(key)) continue;
+                if (typeof name[key] === "string" && name[key].trim()) continue;
+                findings.push({
+                    file: note.file,
+                    ...nameAt([key]),
+                    severity: "error",
+                    message: `\`name.${key}\` must be a nonempty string`,
+                });
+            }
+        }
     }
     /**
      * The in-block keys this note's own type claims for something other than

package/engine/helpers.mjs

@@ -26,6 +26,7 @@
  */
 
 import { buildReferenceTargets } from "./reference-targets.mjs";
+import { standingsDigest } from "./standings.mjs";
 
 import { decodeNoteAddresses } from "./note-addresses.mjs";
 import { positionOfYamlPath } from "./diagnostics.mjs";
@@ -834,6 +835,10 @@ export function buildContentLinkIndex(
             // can group by the family its target declares rather than only by
             // where the target lives.
             subType: fm.subType ?? null,
+            // The rungs and posts this body confers, carried for the same
+            // reason: a being holds a rank as a number, and the body is where
+            // what that number is called is declared.
+            standings: standingsDigest(fm) ?? null,
             name: fm.name?.full ?? base,
             // Whether the note is tagged `draft`. Read from the tag
             // vocabulary that declares it, and used for one thing: a link

package/engine/infobox-render.mjs

@@ -139,7 +139,12 @@ function sectionToHtml(section, link) {
     if (section.layout === "rows") {
         out.push('<dl class="infobox-rows">');
         for (const row of section.rows ?? []) {
-            out.push(`<dt>${escapeHtml(row.label)}</dt><dd>${valueToHtml(row, link)}</dd>`);
+            // A row that declares an anchor carries it on the `<dt>`, so the
+            // label is the destination a link to that row arrives at. A row
+            // that declares none emits none: an id nobody wrote would be
+            // invented once per renderer, and the two would not agree.
+            const id = row.id ? ` id="${escapeHtml(row.id)}"` : "";
+            out.push(`<dt${id}>${escapeHtml(row.label)}</dt><dd>${valueToHtml(row, link)}</dd>`);
         }
         out.push("</dl>");
     } else if (section.layout === "grid") {

package/engine/infobox.mjs

@@ -121,6 +121,7 @@ import { subtypeRow } from "./document-subtypes.mjs";
 import { authoredKey } from "./system-block.mjs";
 import { formatDateInCalendar, formatNoteDate, parseNoteDate } from "./note-dates.mjs";
 import { displayBeingHeight, displayBeingWeight } from "./being-measurements.mjs";
+import { officeAnchor, officeRoster, readStandings, standingPhrase } from "./standings.mjs";
 
 /**
  * How a section arranges what it holds.
@@ -553,8 +554,92 @@ function rowValue(kind, raw, resolve, hint) {
     return presentValue(raw);
 }
 
+/**
+ * A being's memberships, each with the standing it holds there.
+ *
+ * One row, one entry per body, and the standing reads inside the entry rather
+ * than beside it — "War Chief, of Vrystwald Tribes" rather than a rank link
+ * with nothing saying which body confers it.
+ *
+ * **The office carries the link where the body's page anchors it.** An office's
+ * description is already declared in the body's own `governance.offices`, and
+ * the row that prints it is anchored by the same derivation, so the string a
+ * being wrote reaches the description without anyone authoring a note about the
+ * post. In a medium with no page to reach — a compendium journal links by
+ * document UUID — the entry keeps the body's own document, so the reader still
+ * lands somewhere.
+ *
+ * @param {object} field - The declaration.
+ * @param {unknown} raw - The authored value, in either form.
+ * @param {(ref: unknown, hint?: object) => object|undefined} resolve - The
+ *   medium's resolver.
+ * @param {string} label - The row's label.
+ * @returns {object[]} The row, or none where nothing is held.
+ */
+function standingRows(field, raw, resolve, label) {
+    const { entries } = readStandings(raw);
+    const value = [];
+    for (const { body, standing } of entries) {
+        if (!hasValue(body)) continue;
+        const link = linkValue(body, resolve, { type: field.ref });
+        const digest = resolve?.(body, { type: field.ref })?.standings;
+        const text = standingPhrase(standing, link.text, digest);
+        const anchor =
+            (
+                typeof standing?.office === "string" &&
+                digest?.offices?.[standing.office] !== undefined
+            ) ?
+                officeAnchor(standing.office)
+            :   "";
+        value.push({
+            ...link,
+            text,
+            ...(anchor && link.url ? { url: `${link.url}#${anchor}` } : {}),
+        });
+    }
+    return value.length ? [{ label, kind: "links", value }] : [];
+}
+
+/**
+ * A map of named posts, one row each, anchored by its name.
+ *
+ * The **name is the label and its description is the value**, which is the way
+ * round a reader needs: a field name belongs in the label column, and a whole
+ * sentence there leaves the post itself standing where a value goes.
+ *
+ * Each row carries the anchor its name derives, so the description is a
+ * destination rather than merely text on a page — which is what lets a being's
+ * `office` string link to the post it names without anyone authoring a note
+ * about the post.
+ *
+ * @param {unknown} raw - The authored map.
+ * @returns {object[]|null} One row per post, in the order the body declared
+ *   them, or `null` where the value is not a map of them — a note writing
+ *   something else keeps its row and states what it wrote.
+ */
+function rosterRows(raw) {
+    if (!isMapping(raw) || isAddressTuple(raw)) return null;
+    const rows = [];
+    for (const [post, description] of officeRoster(raw)) {
+        if (!hasValue(post)) continue;
+        const anchor = officeAnchor(post);
+        rows.push({
+            ...(anchor ? { id: anchor } : {}),
+            label: String(post),
+            kind: "text",
+            value: hasValue(description) ? String(description) : String(post),
+        });
+    }
+    return rows;
+}
+
 /** Expand structured references using the existing linked-row shape. */
 function structuredRows(field, raw, resolve, label, fm) {
+    if (field.standings) return standingRows(field, raw, resolve, label);
+    if (field.roster) {
+        const roster = rosterRows(raw);
+        if (roster) return roster;
+    }
     if (Array.isArray(raw) && raw.some(isMapping)) {
         const links = raw
             .filter((entry) => isMapping(entry) && hasValue(entry.to))
@@ -706,6 +791,9 @@ function noteBox(
     const shown = new Set();
     const name = fm?.name?.full ?? fm?.title;
     if (hasValue(name)) rows.push({ label: "Name", kind: "text", value: String(name) });
+    if (Array.isArray(fm?.name?.aliases) && fm.name.aliases.length) {
+        rows.push({ label: "Aliases", kind: "list", value: fm.name.aliases });
+    }
     if (fm?.type === "being" && Object.hasOwn(BEING_SUBTYPE_LABELS, fm.subType)) {
         rows.push({ label: "Type", kind: "text", value: BEING_SUBTYPE_LABELS[fm.subType] });
     }

package/engine/note-addresses.mjs

@@ -62,8 +62,12 @@ export const STRUCTURED_ADDRESSES = Object.freeze([
 export function addressPositions(fm, context = {}) {
     const out = [];
     for (const field of dataFields(fm.type) ?? []) {
+        // A field that admits both a list and a map declares both halves, and
+        // which one a note wrote is not knowable from the declaration — so the
+        // position says "either" and the conversion reads the value's shape.
         const shape =
             field.kind === "address" ? "value"
+            : field.kind === "list-or-map" ? "keys-or-list"
             : field.keyKind === "address" ? "keys"
             : field.entryKind === "address" ? field.kind
             : undefined;
@@ -197,7 +201,7 @@ export function decodeNoteAddresses(fm, context) {
                 `\`${path.join(".")}\` ${description}: ${JSON.stringify(value)}`,
             );
             error.keyPath = path;
-            error.addressKey = position.shape === "keys";
+            error.addressKey = position.shape === "keys" || position.shape === "keys-or-list";
             throw error;
         };
         const read = (value, path) => {
@@ -217,7 +221,16 @@ export function decodeNoteAddresses(fm, context) {
         };
         const convert = (value, path) => {
             if (value == null || value === "") return value;
-            if (position.shape === "keys") {
+            // Whichever of the two shapes the note wrote, read as that one. An
+            // empty list is the property editor's emptied map and converts to
+            // nothing either way.
+            const shape =
+                position.shape === "keys-or-list" ?
+                    Array.isArray(value) && value.length ?
+                        "list"
+                    :   "keys"
+                :   position.shape;
+            if (shape === "keys") {
                 if (value instanceof AddressEntries) return value;
                 if (Array.isArray(value) && value.length === 0) return value;
                 if (typeof value !== "object" || Array.isArray(value))
@@ -230,15 +243,11 @@ export function decodeNoteAddresses(fm, context) {
                     })),
                 );
             }
-            if (position.shape === "list") {
+            if (shape === "list") {
                 if (!Array.isArray(value)) fail(value, path, "must be a list of Addresses");
                 return value.map((v, i) => read(v, [...path, i]));
             }
-            if (
-                position.shape === "scalar-or-map" &&
-                typeof value === "object" &&
-                !isAddressTuple(value)
-            ) {
+            if (shape === "scalar-or-map" && typeof value === "object" && !isAddressTuple(value)) {
                 if (Array.isArray(value)) {
                     if (!value.length) return value;
                     fail(value, path, "must be an Address or pack map");

package/engine/note-frontmatter.mjs

@@ -24,6 +24,12 @@ export const NOTE_TOP_LEVEL_KEYS = Object.freeze([
 /** Membership test for the top-level vocabulary. */
 export const NOTE_TOP_LEVEL_KEY_SET = new Set(NOTE_TOP_LEVEL_KEYS);
 
+/** The name properties every note accepts, in display order. */
+export const NOTE_NAME_KEYS = Object.freeze(["full", "aliases"]);
+
+/** Additional name components accepted by an individual character. */
+export const CHARACTER_NAME_KEYS = Object.freeze(["given", "clan"]);
+
 /** Return authored keys from an opening YAML frontmatter map. */
 export function authoredNoteKeys(markdown) {
     const source = markdown.match(/^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/)?.[1];

package/engine/note-vocabulary.mjs

@@ -97,6 +97,8 @@ import {
 // question, asked the way `checkPlace` and `checkCalendarNote` are.
 import { checkBeingAge } from "./being-age.mjs";
 import { checkSocialTies } from "./social-ties.mjs";
+import { checkStandings } from "./standings.mjs";
+import { STANDING_BODY_TYPES } from "./standing-terms.mjs";
 import { checkDatedOffices } from "./office-holders.mjs";
 import { checkCalendarChoice } from "./calendar-choice.mjs";
 import { checkCultureChoice } from "./culture-choice.mjs";
@@ -128,12 +130,20 @@ import { positionOfFrontmatterPath } from "./diagnostics.mjs";
  * @typedef {object} DataFieldSpec
  * @property {string} name - The key under `data:`, dotted for a nested one
  *   (`charges.value`).
- * @property {"string"|"number"|"boolean"|"list"|"map"|"scalar-or-map"|"address"|"shortcode"} [kind] -
+ * @property {"string"|"number"|"boolean"|"list"|"map"|"list-or-map"|"scalar-or-map"|"address"|"shortcode"} [kind] -
  *   The value's shape, for the lint. Absent means no claim is made about the
  *   value — which is the honest answer wherever the specification's stated
  *   shape and the shape notes are authored in today disagree.
  * @property {"address"|"shortcode"} [entryKind] - Type of each list or pack-map value.
- * @property {"address"|"shortcode"} [keyKind] - Type of each map key.
+ * @property {"address"|"shortcode"} [keyKind] - Type of each map key. On a
+ *   `list-or-map` field it describes the map form alone, and `entryKind` the
+ *   list form alone: reading both of one value would check a map's entries as
+ *   if they were its keys.
+ * @property {boolean} [standings] - The map's entries are standings held in the
+ *   body each is keyed by, so a row names the two together — see
+ *   {@link module:engine/standings}.
+ * @property {boolean} [roster] - The map names posts, each with a description,
+ *   so each takes a row labelled and anchored by the post's own name.
  * @property {"subType"} [keySelector] - An alternative `subType:<skill-subtype>` key.
  * @property {readonly string[]} [accepts] - Allowed Address types, separate from `ref`.
  * @property {string} [shape] - Human-readable shape, for a finding and for
@@ -214,6 +224,29 @@ const LINK = Object.freeze({ shape: "an Address", kind: "address" });
 /** A list of Addresses. */
 const LINKS = Object.freeze({ shape: "list of Addresses", kind: "list", entryKind: "address" });
 
+/**
+ * A being's memberships, and the standing it holds in each.
+ *
+ * A map keyed by the body's Address, whose entry is that membership's `rank`
+ * and `office` — the pair a flat list of bodies cannot state, because it has
+ * nowhere to say which body a standing is held in.
+ *
+ * **`list-or-map` is the sweep's shape**, and it says which half each
+ * declaration describes: `entryKind` the list's entries, `keyKind` the map's
+ * keys. A tree still writing the list form keeps the check it had, and the map
+ * form earns the two the body can answer — see {@link module:engine/standings}.
+ */
+const STANDINGS = Object.freeze({
+    shape: "a standing map keyed by Address, or a list of Addresses",
+    kind: "list-or-map",
+    entryKind: "address",
+    keyKind: "address",
+    standings: true,
+    ref: "affiliation",
+    accepts: STANDING_BODY_TYPES,
+    check: checkStandings,
+});
+
 /**
  * A single Address, or one per pack.
  *
@@ -666,6 +699,25 @@ export function isGmNote(fm) {
     return hasTag(fm, GM_TAG);
 }
 
+/** The case-sensitive archetypes and their author-facing meanings. */
+export const BEING_ARCHETYPES = Object.freeze({
+    warrior: "Can hold a line and win a fight.",
+    skirmisher: "Fights light — ambush, missile, mobility.",
+    infiltrator: "Gets in unseen — locks, stealth, disguise.",
+    mage: "Commands arcane practice.",
+    cleric: "Commands religious practice and standing.",
+    healer: "Treats wounds and illness.",
+    scholar: "Reads, researches, and knows things.",
+    courtier: "Navigates rank, negotiation, and intrigue.",
+    woodsman: "Travels and survives wild country.",
+    mariner: "Handles boats and blue water.",
+    artisan: "Builds, repairs, and appraises craft work.",
+    trader: "Moves goods, values them, and knows markets.",
+    commoner: "Fits no more specific archetype; handles ordinary work and daily life.",
+    entertainer: "Performs for an audience through acting, music, comedy, or similar arts.",
+    guildsperson: "Has professional training, standing, or connections that open doors.",
+});
+
 /**
  * Every note type this toolchain compiles, and the closed vocabulary it
  * declares.
@@ -706,7 +758,8 @@ export const NOTE_VOCABULARY = Object.freeze({
                 ref: "lore",
                 accepts: ["lore"],
                 describe:
-                    "Lore concerning this being, such as the standing it holds or the law it lives under.",
+                    "Lore concerning this being — the law it lives under, the customs it is " +
+                    "subject to, the traditions it was raised in.",
             },
             {
                 name: "culture",
@@ -725,10 +778,11 @@ export const NOTE_VOCABULARY = Object.freeze({
             },
             {
                 name: "affiliations",
-                ...LINKS,
-                ref: "affiliation",
-                accepts: ["affiliation"],
-                describe: "Affiliations the being belongs to — traditions, polities, and the rest.",
+                ...STANDINGS,
+                describe:
+                    "Bodies the being belongs to, keyed by Address, each entry holding the " +
+                    "standing it holds there — `rank`, a level on that body's own ladder, " +
+                    "and `office`, a post that body names.",
             },
             {
                 name: "socialTies",
@@ -882,6 +936,10 @@ export const NOTE_VOCABULARY = Object.freeze({
             {
                 name: "governance.offices",
                 ...ANY,
+                // A map of named posts: each takes a row of its own, labelled
+                // by the post and anchored by it, so the description a body
+                // declares is a destination a being's `office` can link to.
+                roster: true,
                 check: checkDatedOffices,
                 describe: "Named offices, each with a description and optional dated holders.",
             },

package/engine/reference-targets.mjs

@@ -8,6 +8,7 @@ import { completeAddress, ownDocumentSystem, renderAddress } from "./address.mjs
 import { NOTE_SYSTEM } from "./systems.mjs";
 import { JOURNAL_TYPES } from "./ids.mjs";
 import { hasDocEntry } from "./item-docs.mjs";
+import { standingsDigest } from "./standings.mjs";
 
 /**
  * Names and published destinations for reference presentation.
@@ -21,7 +22,18 @@ export function buildReferenceTargets(records, published = new Map()) {
     const targets = new Map();
     for (const record of records) {
         if (!record.package || !record.type || !record.shortcode) continue;
-        const value = { name: record.name?.full ?? record.name, subType: record.subType };
+        // `subType` and the standings a body confers both ride along for the
+        // same reason: a caller resolving a reference often needs to know what
+        // it found, not only where it is. A rank is a number on the *being*
+        // and what that number is called is declared on the *body*, so the
+        // ladder travels with the reference rather than being looked up a
+        // second way.
+        const standings = standingsDigest(record);
+        const value = {
+            name: record.name?.full ?? record.name,
+            subType: record.subType,
+            ...(standings ? { standings } : {}),
+        };
         const systems = new Set([ownDocumentSystem(record.type)]);
         if (JOURNAL_TYPES.has(record.type) || hasDocEntry(record.type)) systems.add(NOTE_SYSTEM);
         for (const system of systems) {

package/engine/retired-fields.mjs

@@ -48,13 +48,8 @@
  * nothing checks unrecognized top-level keys, so left in place it would be
  * silently ignored rather than reported.
  *
- * **`name.aliases` fed the same index and is nonetheless kept.** It is
- * **reserved** — held for a use that does not exist yet — so it is the one
- * field here that is neither retired nor read. Nothing consults it: no index,
- * no resolver, no lint rule, no emitter. A note carrying one compiles,
- * resolves and emits exactly as if it were absent, and `tests/name-aliases-
- * reserved.test.ts` pins that equivalence so a future reader cannot be added
- * by accident.
+ * **`name.aliases` lists alternate names.** The note infobox shows them in
+ * authored order. They do not create addresses or change link resolution.
  *
  * **What `traits:` did.** It held a being's own description — gender,
  * species, age, birth date, height, weight, frame and `appearance.*` — at the
@@ -199,10 +194,8 @@ export function assertNoDraftField(fm, { file, absPath } = {}) {
  * unambiguous folded in every note's `name.full` and so dictated what a note
  * could be named. The form is retired, so the list has no reader.
  *
- * **`name.aliases` is a different field and is not retired.** It fed the same
- * index, but unlike the top-level list it is being kept — reserved, unread,
- * and deliberately unmentioned by this message, which would otherwise tell an
- * author to delete a field they are allowed to write. See
+ * **`name.aliases` is a different field.** It lists alternate names in the
+ * infobox and is deliberately unmentioned by this message. See
  * {@link assertNoAliasesField}.
  *
  * @param {string} [file] - The note's path, named in the message. Omit it where
@@ -227,13 +220,9 @@ export function aliasesRetiredMessage(file) {
  * it reads as "this note claims no other names", a statement about a namespace
  * that no longer exists.
  *
- * **The nested `name.aliases` is deliberately not refused.** Both spellings fed
- * the retired alias index, and both lost their reader with it, but only the
- * top-level one is retired: `name.aliases` is **reserved**, held for a use that
- * does not exist yet. So it is neither refused nor read — no index consults it,
- * no rule validates its contents, nothing derives from it, and nothing emits
- * it. It rides in the note as inert data, and a note carrying one compiles,
- * resolves and emits exactly as if it were absent.
+ * **The nested `name.aliases` is deliberately not refused.** It is the note's
+ * ordered alternate names and appears in the note infobox. It does not create
+ * addresses or change how authored links resolve.
  *
  * That distinction is the reason this checks `Object.hasOwn(fm, "aliases")`
  * rather than resolving a dotted key: the top-level field is the whole subject,

package/engine/site-index.mjs

@@ -50,6 +50,7 @@
  */
 
 import { buildReferenceTargets } from "./reference-targets.mjs";
+import { standingsDigest } from "./standings.mjs";
 
 import { resolveShortcodeReference } from "./shortcode-references.mjs";
 
@@ -218,11 +219,16 @@ export function buildSiteIndex(
         // needs to know what it found, not only where it is: an infobox groups
         // a being's skills by the family each skill note declares, and that
         // fact lives on the target rather than on the reference.
+        // The rungs and posts a body confers, carried for the same reason
+        // `subType` is: a being states a rank as a number, and what that
+        // number is called is declared on the body.
+        const standings = standingsDigest(e.fm);
         const value = {
             url: e.url,
             name: e.name,
             draft: isDraftNote(e.fm),
             ...(e.fm.subType ? { subType: e.fm.subType } : {}),
+            ...(standings ? { standings } : {}),
         };
 
         const shortcode = e.fm.shortcode;
@@ -343,7 +349,13 @@ export function resolveInfoboxRef(siteIndex, ref, hint) {
             hint,
         );
         return found ?
-                { name: found.name, url: found.url, subType: found.subType, address: found.address }
+                {
+                    name: found.name,
+                    url: found.url,
+                    subType: found.subType,
+                    address: found.address,
+                    ...(found.standings ? { standings: found.standings } : {}),
+                }
             :   undefined;
     }
     const context = {
@@ -357,6 +369,13 @@ export function resolveInfoboxRef(siteIndex, ref, hint) {
     const found =
         siteIndex.referenceTargets?.get(renderAddress(tuple)) ??
         siteIndex.index?.get(renderAddress(tuple));
-    if (found) return { name: found.name, url: found.url, subType: found.subType, address: tuple };
+    if (found)
+        return {
+            name: found.name,
+            url: found.url,
+            subType: found.subType,
+            address: tuple,
+            ...(found.standings ? { standings: found.standings } : {}),
+        };
     return undefined;
 }