@heroiclands/package-build 10.0.1 → 11.1.0

package/engine/content-slug.mjs

@@ -12,50 +12,39 @@
  */
 
 /**
- * The URL segment of a content note — derived from its name.
- *
- * Content notes carry no authored `slug`: it was a hand-maintained second
- * spelling of something already determined, free to drift from the page it
- * named. The URL is derived instead.
- *
- * It is derived from the **name**, deliberately not from the `shortcode`, even
- * though `(type, shortcode)` is unique by rule and would be a tempting key. A
- * shortcode is *identity*: it is referenced from saved world data — actions,
- * cohorts, expressions, archetypes, pack lookups — so binding the public URL to
- * it would make a cosmetic URL change into a data migration. A URL is
- * presentation, and it should read like one (`/creature/nusvorroth/`, not
- * `/creature/nsvrroth/`). Renames are what a URL must survive, and they do:
- * every change appends to the legacy-URL map, which emits a redirect.
- *
- * **One normalisation, for every slug this build makes.** {@link slugify} is it.
- * Two things are layered on top of it for **document identity** only, in
- * {@link contentSlug}:
- *
- * - it must produce something, and throws when a name yields no slug;
- * - it **abbreviates** — see {@link ABBREVIATIONS}.
- *
- * Abbreviation stops at the document's own address on purpose. A heading anchor
- * is not a name the build invents: an author writes the matching key by hand —
- * a map note pins `locations.stair-foot` at a heading called *Stair Foot* — so a
- * slug that silently became `stair-ft` would break a reference nobody could
- * have predicted. The same goes for a pack filename, which is only ever read
- * back by the unpacker. Shortening either buys nothing and costs the author's
- * ability to guess the key.
- *
- * This header used to claim the opposite — that anchor slugs, filename slugs and
- * this one were deliberately separate operations. Three of them had drifted into
- * dropping non-ASCII letters instead of transliterating them, so `Kûrbúl Helm`
- * addressed a page at `kurbul-helm` while its pack file was `k-rb-l-helm` and a
- * link to a heading of the same name pointed at `#k-rb-l-helm`. Twenty-two of
- * this repository's notes were affected. That was not a design; it was three
- * copies of a regex, and the differences between them were all mistakes.
+ * One normalisation, for every slug this build makes.
+ *
+ * {@link slugify} reduces a piece of prose — a heading, a document name — to a
+ * URL-safe token. It is **not** how a page is addressed: a note's URL is its
+ * address, `type-shortcode`, derived in `engine/content-address.mjs` and
+ * touching no display string at all (#181).
+ *
+ * That used to be the other way round. This module carried a `contentSlug` that
+ * derived a page's URL from `name.full`, abbreviating it through a table of 200
+ * words so the result stayed short, and a `findSlugCollisions` to catch the two
+ * notes that would then claim one URL. Its own header justified the readability
+ * cost with a rename-survival story — *"every change appends to the legacy-URL
+ * map, which emits a redirect"* — and no such map was ever written, in this
+ * package or in any consumer. So a rename silently 404'd every existing link,
+ * a display string was load-bearing, and a uniqueness check was needed to keep
+ * it correct. An address has none of those properties, so all three went.
+ *
+ * What is left is the normalisation the rest of the build still needs, in the
+ * two places it was always right for:
+ *
+ * - **heading anchors**, where an author writes the matching key by hand — a map
+ *   note pins `locations.stair-foot` at a heading called *Stair Foot*;
+ * - **pack filenames**, read back only by the unpacker.
+ *
+ * Neither is abbreviated, and neither ever was: abbreviation existed solely to
+ * shorten a name-derived URL, so it left with it.
  *
  * What the rule does, and why:
  *
  * - **Transliterate, don't discard.** `unidecode` carries every non-ASCII letter
  *   to its ASCII sense — `æ` → `ae`, `þ` → `th`, `œ` → `oe`, `ß` → `ss`,
  *   `ö` → `o`, `¾` → `3/4`. A rule that merely strips them turns a name into
- *   punctuation.
+ *   punctuation, which is how `Kûrbúl Helm` once became `k-rb-l-helm`.
  * - **An apostrophe elides.** `’` and `'` mark a pronunciation break — a glottal
  *   stop — inside one word, so `Kenbet’Pat` is `kenbetpat`, not `kenbet-pat`.
  * - **Everything else non-alphanumeric becomes a hyphen**, collapsed and
@@ -70,31 +59,26 @@
 
 import unidecode from "unidecode";
 
-import { abbreviateTokens } from "./abbreviations.mjs";
-
 /**
- * The URL segment for one content note.
+ * The URL-safe token a piece of prose reduces to.
  *
- * The name is **transliterated** before it is reduced, so an accented character
- * is carried across rather than dropped — dropping is what turned `Nüsvōrroth`
- * into `n-sv-rroth` and forced a hand-written slug. Ligatures expand the way a
- * reader would spell them out: `þ`→`th`, `æ`→`ae`, `œ`→`oe`, `ß`→`ss`, `ij`→`ij`,
- * `fi`→`fi`, and eth (`ð`) follows the Icelandic convention of a bare `d`.
+ * The text is **transliterated** before it is reduced, so an accented character
+ * is carried across rather than dropped. Ligatures expand the way a reader would
+ * spell them out: `þ`→`th`, `æ`→`ae`, `œ`→`oe`, `ß`→`ss`, `ij`→`ij`, `fi`→`fi`,
+ * and eth (`ð`) follows the Icelandic convention of a bare `d`.
  *
  * Two reductions are ours rather than the transliterator's:
  *
  * - **apostrophes are removed**, not treated as separators (`Armorer's Kit` →
- *   `armorers-kit`), matching the URLs these pages already publish at;
+ *   `armorers-kit`);
  * - **a fraction keeps its digits together** — a vulgar fraction expands to
  *   `3/4`, and the solidus would otherwise split it into `3-4`, so a slash
  *   *between digits* is closed up (`Kûrbúl ¾-Helm` → `kurbul-34-helm`).
  *
- * @param {string | undefined} name - The note's display name (`name.full`),
- *   which a malformed note may not have at all.
- * @returns {string} The URL segment (never empty).
- * @throws {Error} When there is no name, or the name carries no URL-safe
- *   characters — either way the note cannot be addressed, which is a content
- *   error rather than something to paper over with a fallback.
+ * @param {string | undefined} text - The prose to reduce.
+ * @returns {string} The token, or `""` when the text carries nothing URL-safe.
+ *   Empty is an ordinary answer here: nothing is addressed by a slug any more,
+ *   so an anchor that reduces to nothing is the caller's to judge.
  */
 export function slugify(text) {
     const raw = typeof text === "string" ? text.trim() : "";
@@ -102,10 +86,10 @@ export function slugify(text) {
     const tokens = unidecode(raw)
         .toLowerCase()
         // An apostrophe marks a pronunciation break, not a word boundary:
-        // `Kenbet\u2019Pat` is one name said with a catch in it, so it elides
+        // `Kenbet’Pat` is one name said with a catch in it, so it elides
         // rather than becoming a hyphen.
         .replace(/['\u2019]/g, "")
-        // A vulgar fraction transliterates to its digits (`\u00be` \u2192 `3/4`); the
+        // A vulgar fraction transliterates to its digits (`¾` → `3/4`); the
         // solidus between them is not a word boundary either.
         .replace(/(\d)\/(\d)/g, "$1$2")
         .split(/[^a-z0-9]+/)
@@ -113,53 +97,3 @@ export function slugify(text) {
 
     return tokens.join("-");
 }
-
-/**
- * The URL segment a content note publishes at.
- *
- * {@link slugify} with the rule that a document *must* be addressable: a note
- * that yields no slug is a content error, not something to paper over with a
- * fallback, because the alternative is a page nobody can reach.
- *
- * @param {string | undefined} name - The note's display name (`name.full`),
- *   which a malformed note may not have at all.
- * @returns {string} The URL segment (never empty).
- * @throws {Error} When there is no name, or the name carries no URL-safe
- *   characters.
- */
-export function contentSlug(name) {
-    const raw = typeof name === "string" ? name.trim() : "";
-    if (!raw) {
-        throw new Error("content note has no name, so it has no URL");
-    }
-    const normalised = slugify(raw);
-    const slug = abbreviateTokens(normalised.split("-").filter(Boolean)).join("-");
-    if (!slug) {
-        throw new Error(`name "${raw}" has no URL-safe characters, so it cannot address a page`);
-    }
-    return slug;
-}
-
-/**
- * Find pages that would publish to the same URL.
- *
- * Nothing constrains two notes in one section from sharing a name, and a
- * collision silently overwrites one page with the other. This turns it into a
- * build failure that names every claimant, so the fix is a more specific title.
- * (The content tree has no collisions today.)
- *
- * @param {Array<{sec: string, slug: string, src: string}>} pages
- * @returns {Array<{url: string, sources: string[]}>} One entry per collision, in
- *   first-claim order; empty when every URL is unique.
- */
-export function findSlugCollisions(pages) {
-    const byUrl = new Map();
-    for (const { sec, slug, src } of pages) {
-        const url = `/${sec}/${slug}/`;
-        if (!byUrl.has(url)) byUrl.set(url, []);
-        byUrl.get(url).push(src);
-    }
-    return [...byUrl.entries()]
-        .filter(([, sources]) => sources.length > 1)
-        .map(([url, sources]) => ({ url, sources }));
-}

package/engine/diagnostics.mjs

@@ -181,16 +181,27 @@ export function positionInBody(body, offset, { bodyLine = 1, bodyColumn = 1, lin
  * a line of prose — sending the reader to a position that is not the problem,
  * which is the one thing the located form exists to prevent.
  *
+ * The key match tolerates leading whitespace by default, so a nested key of the
+ * same name answers when no top-level one is present — which is usually what a
+ * reader wants, the key being unique in nearly every note. Pass `topLevel` where
+ * it is not: `aliases` is both a retired top-level field and a **permitted**
+ * `name.aliases` (#180), and a finding about the first must never open on the
+ * second, which would tell an author to delete a field they are allowed to
+ * write.
+ *
  * @param {string} raw - The file's full contents, frontmatter included.
  * @param {string} key - The top-level frontmatter key.
  * @param {string} [value] - When given, prefer the occurrence whose line also
  *   carries this text. A list-valued key (`aliases`) is reported at the entry
  *   that is wrong, not at the key that introduces it.
+ * @param {object} [options] - Options.
+ * @param {boolean} [options.topLevel=false] - Require the key at column 1, so
+ *   an identically named nested key cannot answer for it.
  * @returns {{line?: number, column?: number}} Spreadable position fields, empty
  *   when the key cannot be located — dropped rather than guessed, as
  *   {@link formatDiagnostic} requires.
  */
-export function positionInFrontmatter(raw, key, value = undefined) {
+export function positionInFrontmatter(raw, key, value = undefined, { topLevel = false } = {}) {
     if (typeof raw !== "string" || !key) return {};
     const fence = raw.match(/^---\n([\s\S]*?)\n---/);
     if (!fence) return {};
@@ -205,7 +216,10 @@ export function positionInFrontmatter(raw, key, value = undefined) {
             keyLine = i;
             break;
         }
-        if (keyLine === -1 && new RegExp(`^\\s*${escape(key)}\\s*:`).test(lines[i])) {
+        if (
+            keyLine === -1 &&
+            new RegExp(`^${topLevel ? "" : "\\s*"}${escape(key)}\\s*:`).test(lines[i])
+        ) {
             keyLine = i;
             if (wanted == null) break;
         }

package/engine/frontmatter-lint.mjs

@@ -55,7 +55,10 @@
  * @module
  */
 
+import path from "node:path";
+
 import { authoredFields } from "./field-spec.mjs";
+import { DEFAULT_ADDRESS_SCHEME, sectionOf } from "./content-address.mjs";
 import { resolveFieldValue, SYSTEM_BLOCK_KEYS, unknownBlockKeys } from "./system-block.mjs";
 import { positionInFrontmatter, positionOfFrontmatterPath } from "./diagnostics.mjs";
 import { checkHomepageAddressFields } from "./homepage.mjs";
@@ -64,6 +67,8 @@ import { declaredTags } from "./note-vocabulary.mjs";
 import {
     RETIRED_FIELD_ALIASES,
     declaresRetiredAlias,
+    aliasesRetiredMessage,
+    declaresRetiredAliasesField,
     draftRetiredMessage,
     readAliasedField,
     retiredAliasMessage,
@@ -311,22 +316,83 @@ function checkDataContainer(note, { type, fields }) {
     return findings;
 }
 
+/**
+ * Whether this note's `subType` names the **section it lands at** rather than a
+ * sub-kind of its type (#197).
+ *
+ * Under `landing: readme` a `README.md` addresses its whole section, and the
+ * segment is what `sectionOf` reads — for a `doc`, its `subType`. So that one
+ * field is spelled once and read twice: as a genre on an ordinary note, and as
+ * an address on a landing. The two vocabularies are not the same set, and the
+ * closed one cannot answer for the open one.
+ *
+ * Asked of {@link sectionOf} rather than by naming a type, because which types
+ * route by their `subType` is address knowledge and this module deliberately
+ * knows no type names of its own.
+ *
+ * @param {object} note - The note.
+ * @param {string} landing - The repository's landing rule.
+ * @returns {boolean} Whether the value is an address.
+ */
+function subTypeIsSection(note, landing) {
+    if (landing !== "readme") return false;
+    const file = typeof note.file === "string" ? note.file : "";
+    if (path.basename(file).toLowerCase() !== "readme.md") return false;
+    const fm = note.fm ?? {};
+    return typeof fm.subType === "string" && sectionOf(fm) === fm.subType;
+}
+
 /**
  * Check a note's top-level `subType` against the values its type declares
- * (#128).
+ * (#128), or — for a `README` landing — against the sections that can exist
+ * (#197, #200).
  *
  * `subType` stays at the top level — it is what each system's map reads to
  * derive a document type, so it describes the note rather than the subject —
  * but it is not open like the rest of that region: a type either declares a
  * `subType` or does not, and a type that does declares its values.
  *
+ * **A landing page's is an address, and an address is checked against the
+ * addresses that exist.** A `README` under `landing: readme` addresses its
+ * section through this field, and a section is `weapongear` or `being` as
+ * readily as it is `rules`. What can legitimately appear there is the range of
+ * {@link sectionOf} over every note the format permits, plus whatever the
+ * repository names:
+ *
+ * 1. **Every declared content type.** `sectionOf` returns `fm.type` for a
+ *    non-`doc` note, so `being`, `lore` and `weapongear` are sections *by
+ *    construction*, configured or not.
+ * 2. **The type's own subtypes** — `rules`, `user-guide`, `reference` for a
+ *    `doc`, since a `doc` routes by its subtype.
+ * 3. **The configured sections**, which may name one that is neither: `sohl`
+ *    configures `credits` and `dev-docs`.
+ *
+ * Checking only (3) was #197's fix and keyed on configuration a consumer may
+ * legitimately not have: `sohl-thalorna` has no `site:` block at all, so five
+ * of its landings were refused for naming their own content type (#200).
+ *
+ * **The guard survives.** A misspelling is none of the three, so it still
+ * fails, with the near miss drawn from the whole union. What is deliberately no
+ * longer caught is a landing for a section that exists but is empty — which is
+ * legitimate, and is why the set is the types the format *declares* rather than
+ * the types *present in the tree*: `sohl` ships two such landings above tables
+ * that stay empty until the first note of each type does.
+ *
  * @param {object} note - The note.
  * @param {object} opts
  * @param {string} opts.type - The note's type, for the message.
  * @param {object} opts.entry - The type's vocabulary entry.
+ * @param {boolean} [opts.asSection] - Whether the value is a section address —
+ *   see {@link subTypeIsSection}.
+ * @param {readonly string[]} [opts.types] - The content types the format
+ *   declares. Empty leaves a landing checked against its genres and the
+ *   configured sections alone.
+ * @param {readonly string[]} [opts.sections] - The sections the repository
+ *   configures. Empty when it configures none, which is ordinary rather than a
+ *   defect.
  * @returns {object[]} Findings.
  */
-function checkSubType(note, { type, entry }) {
+function checkSubType(note, { type, entry, asSection = false, types = [], sections = [] }) {
     const fm = note.fm ?? {};
     if (!Object.hasOwn(fm, "subType") || fm.subType == null || fm.subType === "") return [];
 
@@ -351,6 +417,28 @@ function checkSubType(note, { type, entry }) {
     // the value is nobody's to check yet.
     if (values == null || values.includes(value)) return [];
 
+    if (asSection) {
+        if (types.includes(value) || sections.includes(value)) return [];
+        const guess = nearest(value, [...types, ...values, ...sections]);
+        return [
+            {
+                file: note.file,
+                ...at,
+                severity: "error",
+                message:
+                    `\`subType\` "${value}" is the section this README lands ` +
+                    `at, and nothing declares it. A section is a content type ` +
+                    `(${types.join(", ")}), a subtype ${type} declares ` +
+                    `(${values.join(", ")})` +
+                    (sections.length ?
+                        `, or a section configured under \`site.sections\` / ` +
+                        `\`site.readmeSections\` (${sections.join(", ")})`
+                    :   "") +
+                    (guess ? `. Did you mean "${guess}"?` : ""),
+            },
+        ];
+    }
+
     const guess = nearest(value, values);
     return [
         {
@@ -433,9 +521,33 @@ function checkTags(note, { type }) {
  * @param {Readonly<Record<string, {known?: readonly string[], fieldVocabulary?: boolean}>>} [opts.systems]
  *   The system blocks to check, and what each accepts. See
  *   {@link DEFAULT_SYSTEM_BLOCKS}.
+ * @param {string} [opts.landing] - The repository's landing rule, from
+ *   `publish.address.landing`. It decides which note addresses a whole section,
+ *   and so whether a `subType` is a genre or an address (#197).
+ * @param {readonly string[]} [opts.types] - The content types the format
+ *   declares — the sections that exist by construction (#200). Read from
+ *   `docs/content-format.md` rather than from `schemas`, because the two answer
+ *   different questions: whether an address is real, and whether this build can
+ *   check a note's fields. A type the specification declares and no schema
+ *   covers is a real section, and its notes are reported on their own account.
+ * @param {readonly string[]} [opts.sections] - The sections the repository
+ *   configures, from `declaredSections`. Supplied by the caller for the same
+ *   reason `vocabulary` is: this module checks a note against what it is
+ *   handed.
  * @returns {object[]} Findings, each with a locator where one is obtainable.
  */
-export function lintNote(note, { schemas, index, vocabulary, systems = DEFAULT_SYSTEM_BLOCKS }) {
+export function lintNote(
+    note,
+    {
+        schemas,
+        index,
+        vocabulary,
+        systems = DEFAULT_SYSTEM_BLOCKS,
+        landing = DEFAULT_ADDRESS_SCHEME.landing,
+        types = [],
+        sections = [],
+    },
+) {
     const findings = [];
     const fm = note.fm ?? {};
     const type = String(fm.type ?? "");
@@ -466,21 +578,32 @@ export function lintNote(note, { schemas, index, vocabulary, systems = DEFAULT_S
             message: draftRetiredMessage(),
         });
     }
+    // Only the top-level `aliases` is retired. `name.aliases` writes the same
+    // key indented under `name:` and is **permitted** — reserved and unread —
+    // so both the test and the locator are anchored at column 1 (#180).
+    if (declaresRetiredAliasesField(fm)) {
+        findings.push({
+            file: note.file,
+            ...positionInFrontmatter(raw(), "aliases", undefined, { topLevel: true }),
+            severity: "error",
+            message: aliasesRetiredMessage(),
+        });
+    }
 
-    // A homepage's address is its package's, so the top-level fields that
-    // decide an address decide nothing on it (#53). Reported beside the retired
-    // fields above because it is the same kind of statement — a top-level key
-    // this note may not write — and, like them, it must survive the two early
+    // What the address rule says about a homepage's top-level fields: the
+    // `shortcode` it owes, and the `id` it may not write (#53, #182). Reported
+    // beside the retired fields above because it is the same kind of statement
+    // about the same note, and, like them, it must survive the two early
     // returns below: the finding stands whatever else the type is.
     // Tags are checked here for the same reason: a classifying tag is not a
     // type's property — `draft` belongs to any note and `village` to a place —
     // so the finding must survive the early returns below.
     findings.push(...checkTags(note, { type }));
 
-    for (const { key, message } of checkHomepageAddressFields(fm)) {
+    for (const { locator, message } of checkHomepageAddressFields(fm)) {
         findings.push({
             file: note.file,
-            ...at(key),
+            ...at(locator.key, locator.literal),
             severity: "error",
             message,
         });
@@ -521,7 +644,15 @@ export function lintNote(note, { schemas, index, vocabulary, systems = DEFAULT_S
     const entry = vocabulary?.[type];
     if (entry) {
         findings.push(...checkDataContainer(note, { type, fields: entry.data ?? [] }));
-        findings.push(...checkSubType(note, { type, entry }));
+        findings.push(
+            ...checkSubType(note, {
+                type,
+                entry,
+                asSection: subTypeIsSection(note, landing),
+                types,
+                sections,
+            }),
+        );
     }
 
     const fields = authoredFields(schema);
@@ -643,15 +774,15 @@ export function lintNote(note, { schemas, index, vocabulary, systems = DEFAULT_S
         // vendored manifest lands exactly as the same address in a wikilink
         // would — rather than through a second, subtly different rule.
         //
-        // **As an address, always.** The resolver's third argument chooses the
-        // namespace and has no fallback (#144): omitted, it reads the target as
-        // an *alias*, and `type-shortcode` is never an alias, so every value a
-        // `ref:` field carries was reported unresolvable (#176). A frontmatter
-        // reference is a bare address by construction — there is no pipe to
-        // read intent from, and the field supplies the type — so it says so.
+        // **As an address, always** — which is now the only namespace there
+        // is (#180). A frontmatter reference is a bare address by construction:
+        // there is no pipe to read intent from, and the field supplies the
+        // type. The resolver once took a namespace argument, and omitting it
+        // read every `ref:` value as an alias, which `type-shortcode` never was
+        // (#176).
         if (field.ref && index && typeof value === "string" && value) {
             const target = `${field.ref}-${value}`;
-            if (!index.resolve(note, target, true) && !index.manifestHit(target)) {
+            if (!index.resolve(target) && !index.manifestHit(target)) {
                 findings.push({
                     file: note.file,
                     ...at(head, value),
@@ -678,10 +809,19 @@ export function lintNote(note, { schemas, index, vocabulary, systems = DEFAULT_S
  * @param {boolean} [opts.references=true] - Whether to check references.
  * @param {Readonly<Record<string, {known?: readonly string[], fieldVocabulary?: boolean}>>} [opts.systems]
  *   The system blocks to check. See {@link DEFAULT_SYSTEM_BLOCKS}.
+ * @param {string} [opts.landing] - The repository's landing rule; see
+ *   {@link lintNote}.
+ * @param {readonly string[]} [opts.types] - The content types the format
+ *   declares; see {@link lintNote}.
+ * @param {readonly string[]} [opts.sections] - The sections the repository
+ *   configures; see {@link lintNote}.
  * @returns {{findings: object[], notes: number}} The findings, and how many
  *   notes were inspected.
  */
-export function lintFrontmatter(index, { schemas, vocabulary, references = true, systems }) {
+export function lintFrontmatter(
+    index,
+    { schemas, vocabulary, references = true, systems, landing, types, sections },
+) {
     const findings = [];
     const notes = [...index.notes].sort((a, b) =>
         a.file < b.file ? -1
@@ -695,6 +835,9 @@ export function lintFrontmatter(index, { schemas, vocabulary, references = true,
                 vocabulary,
                 index: references ? index : undefined,
                 ...(systems ? { systems } : {}),
+                ...(landing ? { landing } : {}),
+                ...(types ? { types } : {}),
+                ...(sections ? { sections } : {}),
             }),
         );
     }

package/engine/helpers.mjs

@@ -39,10 +39,14 @@ import { contentPackage, foundryPackageId } from "./content-package.mjs";
 import { searchableFrontmatter } from "./note-package.mjs";
 import { loadForeignManifests, PACKAGE_BASE } from "./kb-manifest.mjs";
 import { buildWikilinkIndex, convertWikilinks } from "./wikilinks.mjs";
-// The alias sources every index shares (#131).
-import { aliasesOf } from "./alias-index.mjs";
+// One vocabulary of link findings, and one message per class, so the three
+// resolvers cannot word the same defect differently (#184).
+import { linkFindingMessage } from "./wikilink-syntax.mjs";
+// The declared tag vocabulary (#172), which is where `draft` is stated. Read
+// from there rather than respelt, so the tag and its one reader cannot drift.
+import { isDraftNote } from "./note-vocabulary.mjs";
 import { expandContentTables } from "./content-tables.mjs";
-import { emitDiagnostic, positionInBody } from "./diagnostics.mjs";
+import { positionInBody } from "./diagnostics.mjs";
 // The pure `sohl:` frontmatter readers live in a leaf module so the item-type
 // registry can import them without reaching back through this one (#1504).
 // Re-exported here so every existing importer keeps its single import path.
@@ -429,7 +433,7 @@ import { assertTypeNotRetired, packForType } from "./ids.mjs";
  * @param {object} [router] - The pack router. Supplied by the calling pass so
  *   the index and the compile agree about where each note landed; defaults to
  *   this repository's own.
- * @returns {{byShortcode: Map, byAlias: Map}} From `buildWikilinkIndex`.
+ * @returns {{byShortcode: Map, types: Set}} From `buildWikilinkIndex`.
  */
 export function buildContentLinkIndex(contentBase, router = packRouter()) {
     const docs = [];
@@ -450,10 +454,11 @@ export function buildContentLinkIndex(contentBase, router = packRouter()) {
             docPack: router.resolveOrNull(fm, "JournalEntry"),
             shortcode: fm.shortcode ?? null,
             name: fm.name?.full ?? base,
-            // The shared alias sources (#131): `aliases`, `name.aliases` and
-            // `name.full`, and deliberately not the filename — see
-            // {@link aliasesOf} for what that admitted and why it went.
-            aliases: aliasesOf(fm),
+            // Whether the note is tagged `draft` (#183). Read from the tag
+            // vocabulary that declares it, and used for one thing: a link
+            // *into* this note renders marked. It takes no part in resolution,
+            // so the note is indexed, compiled and published as any other.
+            draft: isDraftNote(fm),
         });
     }
     // Packages this build links *into* but does not publish. Their manifests
@@ -500,7 +505,8 @@ export function buildContentLinkIndex(contentBase, router = packRouter()) {
  *   entry. Position is carried by `{ file, bodyLine, bodyColumn, lineMap }`,
  *   the last from {@link expandNoteTables}.
  * @returns {{markdown: string, unresolved: Array<object>}}
- * @throws {Error} On an ambiguous alias or a dead qualified address. The error
+ * @throws {Error} On any link that does not resolve — an unlabelled one, a
+ *   target that is not an address, or an address nothing publishes. The error
  *   carries `file` and `position`, so a caller reports it in the same form
  *   rather than re-deriving one.
  */
@@ -539,70 +545,27 @@ export function convertNoteWikilinks(
      * @returns {never}
      */
     const fail = (u, message) => {
-        const err = new Error(message);
+        const at = locate(u);
+        // A link this build wrote is not at any authored position, so say
+        // where it came from rather than implying an edit site.
+        const err = new Error(
+            at.generated ? `${message} Emitted by the content table on this line.` : message,
+        );
         err.file = file;
-        err.position = locate(u);
+        err.position = at;
         throw err;
     };
 
     for (const u of result.unresolved) {
-        // An ambiguous alias matched real content — twice. There is no
-        // defensible way to pick one, and the correction is mechanical: write
-        // the qualified form. So it fails rather than warning, which also puts
-        // the failure in front of whoever created the collision instead of
-        // leaving it in a log line attributed to an innocent citing note.
-        // The knowledgebase build has always treated this as fatal; agreeing
-        // means one authored note cannot get two verdicts (#13).
-        if (u.reason === "ambiguous") {
-            const claims = u.candidates ?? [];
-            const named =
-                claims.length ?
-                    claims.map((c) => `"${c.name}" (${c.type}-${c.shortcode})`).join(" and ")
-                :   "two or more notes";
-            fail(
-                u,
-                `ambiguous wikilink ${u.link} in "${name}" — claimed by ` +
-                    `${named}. Rename one alias, or address the intended one ` +
-                    `as [[type-shortcode|Text]].`,
-            );
-        }
-        // The author wrote a pipe, so they meant an address — and this target
-        // is not one. Its own message, because the correction is its own: a
-        // note *name* has to become an address, which is not the same job as
-        // fixing a shortcode that resolves nowhere (#131).
-        if (u.reason === "not-an-address") {
-            fail(
-                u,
-                `wikilink ${u.link} in "${name}" is written as an address — ` +
-                    `the "|" says so — but "${u.target}" is not one. Write ` +
-                    `[[type-shortcode|Text]], or drop the "|" to name it as ` +
-                    `an alias within this note's own type.`,
-            );
-        }
-        // A qualified address resolving nowhere is a typo, now that every
-        // linkable package is either built here or vendored (#1499) — so it
-        // fails the note rather than degrading to text. A bare alias stays a
-        // warning: it may be ordinary prose that merely looks like a link.
-        if (u.addressed) {
-            fail(
-                u,
-                `unresolved address ${u.link} in "${name}" — no package ` +
-                    `publishes it. Fix the shortcode, or re-vendor that ` +
-                    `package's manifest into assets/manifests/.`,
-            );
-        }
-        const at = locate(u);
-        emitDiagnostic({
-            file,
-            line: at.line,
-            column: at.column,
-            severity: "warning",
-            message:
-                `unresolved wikilink ${u.link} (${u.reason}) in "${name}"` +
-                // A link this build wrote is not at any authored position, so
-                // say where it came from instead of implying an edit site.
-                (at.generated ? " — emitted by the content table on this line" : ""),
-        });
+        // Every class fails, and every class is worded by the shared table
+        // (#184). The three resolvers read one authored link, so an author who
+        // ran the pack build first and the link checker second must not be told
+        // two different things about the same mistake — and a class the pack
+        // build alone knew how to describe is how they came apart before.
+        //
+        // The note's name is appended rather than woven in: the message is the
+        // defect, the name is the context this build can add.
+        fail(u, `${linkFindingMessage(u)} — in "${name}".`);
     }
     return result;
 }