@heroiclands/package-build 23.0.0 → 23.1.1

package/engine/sql-tables.mjs

@@ -28,7 +28,10 @@
 
 import { parseAddress, renderAddress, isAddressTuple } from "./address.mjs";
 import { NOTE_VOCABULARY, isGmNote } from "./note-vocabulary.mjs";
-import { encodeAddresses } from "./address-values.mjs";
+import { encodeAddresses, flattenPublishedAddresses } from "./address-values.mjs";
+import { EVENT_COLUMNS, EVENT_SORT_COLUMNS, eventRows } from "./event-rows.mjs";
+import { eventViewSections } from "./event-views.mjs";
+import { appendGeneratedSections, joinSections } from "./generated-sections.mjs";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
@@ -211,6 +214,13 @@ export async function openNotesDatabase(
     const connection = await instance.connect();
     await connection.run("SET threads=1");
     await createRelations(connection, jsonl, "", audience);
+    await createEventRelation(
+        connection,
+        path.join(base, "events.jsonl"),
+        records.map((record) => encodeAddresses(record)),
+        "",
+        audience,
+    );
 
     // One schema per declared dependency, so `FROM sohl.notes` reads the notes
     // that package published. Quoted, because a package id may carry a hyphen
@@ -220,7 +230,26 @@ export async function openNotesDatabase(
         if (!dep?.id || !dep?.file || !fs.existsSync(dep.file)) continue;
         const schema = `"${String(dep.id).replace(/"/g, '""')}"`;
         await connection.run(`CREATE SCHEMA IF NOT EXISTS ${schema}`);
-        await createRelations(connection, dep.file, `${schema}.`, audience);
+        // A published index writes each Address as an object; a fence compares
+        // the string an author writes, so each is flattened to it on load.
+        const flat = path.join(
+            base,
+            `dependency-${String(dep.id).replace(/[^a-z0-9]/gi, "_")}.jsonl`,
+        );
+        const depRecords = fs
+            .readFileSync(dep.file, "utf8")
+            .split("\n")
+            .filter((line) => line.trim())
+            .map((line) => flattenPublishedAddresses(JSON.parse(line)));
+        fs.writeFileSync(flat, depRecords.map((record) => JSON.stringify(record)).join("\n"));
+        await createRelations(connection, flat, `${schema}.`, audience);
+        await createEventRelation(
+            connection,
+            flat.replace(/\.jsonl$/, "-events.jsonl"),
+            depRecords,
+            `${schema}.`,
+            audience,
+        );
     }
 
     // The market scale as a relation, so a table prints `village` beside the
@@ -245,6 +274,7 @@ export async function openNotesDatabase(
     // {@link prepareSqlTables}.
     await connection.run(`CREATE SCHEMA IF NOT EXISTS ${WITH_STUBS_SCHEMA}`);
     await connection.run(`CREATE VIEW ${WITH_STUBS_SCHEMA}.notes AS SELECT * FROM entries`);
+    await connection.run(`CREATE VIEW ${WITH_STUBS_SCHEMA}.events AS SELECT * FROM main.events`);
 
     // Whether this index holds a stub at all, asked once. A corpus with none
     // pays nothing for the comparison above, which is every package that has
@@ -394,6 +424,42 @@ async function createRelations(connection, file, prefix = "", audience = "all")
     );
 }
 
+/**
+ * Create the `events` relation: one row per `data.events` entry, across every
+ * note type that carries events, with the columns
+ * {@link module:engine/event-rows.EVENT_COLUMNS} names.
+ *
+ * Its rows are derived from the same records `entries` reads, stubs included —
+ * an event a stub states is still an event — and a GM note's events are left
+ * out on a public surface exactly as the note is. A corpus with no event at all
+ * still has the relation, empty, so a fence over it reports no rows rather than
+ * a missing table.
+ *
+ * @param {object} connection - An open DuckDB connection.
+ * @param {string} file - Where to write the rows.
+ * @param {object[]} records - Index records, every Address a string.
+ * @param {string} prefix - A schema to qualify the view name with.
+ * @param {"all"|"public"} audience - Whether to leave out GM notes.
+ * @returns {Promise<void>}
+ */
+async function createEventRelation(connection, file, records, prefix, audience) {
+    const rows = eventRows(
+        audience === "public" ? records.filter((record) => !isGmNote(record)) : records,
+    );
+    if (!rows.length) {
+        const columns = EVENT_COLUMNS.map((column) => {
+            const type = EVENT_SORT_COLUMNS.includes(column) ? "DOUBLE" : "VARCHAR";
+            return `NULL::${type} AS "${column}"`;
+        });
+        await connection.run(
+            `CREATE VIEW ${prefix}events AS SELECT ${columns.join(", ")} WHERE false`,
+        );
+        return;
+    }
+    fs.writeFileSync(file, rows.map((row) => JSON.stringify(row)).join("\n"));
+    await connection.run(`CREATE VIEW ${prefix}events AS ${readJsonAuto(file)}`);
+}
+
 /**
  * The `read_json_auto` clause both the own-notes view and a dependency's use.
  *
@@ -681,6 +747,106 @@ export async function prepareInlineSqlExpressions(db, sources) {
     return byNote;
 }
 
+/**
+ * Each note's generated sections — the derived lists and the event views — see
+ * {@link module:engine/generated-sections}.
+ *
+ * @param {object|undefined} db - From {@link openNotesDatabase}, over
+ *   `records`; absent, no event view is asked for.
+ * @param {object[]} records - Content-index records, of the audience the
+ *   surface publishes to.
+ * @param {string} contentBase - Root of the content tree.
+ * @param {object} [opts]
+ * @param {string} [opts.only] - One note file to give sections to; absent,
+ *   every note.
+ * @param {Map<string, object>} [opts.foreignIndex] - The fetched indexes, whose
+ *   places, affiliations and works the lists take in.
+ * @param {object} [opts.config] - The resolved configuration.
+ * @param {Map<string, Map<string, string>>} [opts.derived] - The derived
+ *   lists, from an earlier call over the same records, which are not derived
+ *   again.
+ * @returns {Promise<{sections: Map<string, string>, views: Set<string>,
+ *   derived: Map<string, Map<string, string>>}>} Note file to its sections,
+ *   joined in order; the files whose sections hold an event view's fence; and
+ *   the derived lists alone.
+ */
+export async function generatedSectionsFor(
+    db,
+    records,
+    contentBase,
+    { only, foreignIndex, config, derived: given } = {},
+) {
+    const notes = records.filter((record) => isNoteRecord(record));
+    const fileOf = (record) => noteFile(contentBase, record);
+    // Imported here for the cycle reason the index is: the derivations read
+    // the map world, which reaches the content index.
+    const derived =
+        given ??
+        (await import("./derived-sections.mjs")).derivedSections(notes, {
+            fileOf,
+            foreignIndex,
+            config,
+            only,
+        });
+    const views = db ? await eventViewSections(db, notes, fileOf, only) : new Map();
+    const sections = new Map();
+    for (const file of new Set([...derived.keys(), ...views.keys()]))
+        sections.set(file, joinSections([derived.get(file), views.get(file)]));
+    return { sections, views: new Set(views.keys()), derived };
+}
+
+/**
+ * Join each note's generated sections to its body among the sources a
+ * preparation answers, so the fences the event views hold are answered with
+ * the author's own, in order after them. A note whose sections hold a fence
+ * and whose body holds no directive of its own joins the sources, its body
+ * read as {@link prepareTreeSqlTables} reads one.
+ *
+ * The expansion every surface runs appends the same text again, from the
+ * `generated` {@link attachGeneratedSections} sets on the note's results —
+ * see {@link module:engine/content-tables.expandContentTables}.
+ *
+ * @param {{sections: Map<string, string>, views: Set<string>}} generated -
+ *   From {@link generatedSectionsFor}.
+ * @param {Array<{source: string, markdown: string, frontmatter?: object}>} sources -
+ *   The bodies to answer, extended in place.
+ * @returns {void}
+ */
+export function joinGeneratedSections(generated, sources) {
+    for (const [absPath, text] of generated.sections) {
+        const source = sources.find((one) => one.source === absPath);
+        if (source) {
+            source.markdown = appendGeneratedSections(source.markdown, text);
+            continue;
+        }
+        if (!generated.views.has(absPath)) continue;
+        const { body, frontmatter } = parseMarkdownFile(absPath);
+        sources.push({
+            source: absPath,
+            markdown: appendGeneratedSections(body, text),
+            frontmatter,
+        });
+    }
+}
+
+/**
+ * Record each note's generated sections on its prepared results, where the
+ * table expansion reads them. A note with no results of its own is given an
+ * empty set carrying them.
+ *
+ * @param {Map<string, object[]>} prepared - From {@link prepareSqlTables}.
+ * @param {{sections: Map<string, string>}} generated - From
+ *   {@link generatedSectionsFor}.
+ * @returns {void}
+ */
+export function attachGeneratedSections(prepared, generated) {
+    for (const [absPath, text] of generated.sections) {
+        let results = prepared.get(absPath);
+        if (!results) prepared.set(absPath, (results = []));
+        results.generated = text;
+    }
+}
+
 /**
  * Answer every `sql` directive in a content tree.
  *
@@ -706,13 +872,16 @@ export async function prepareInlineSqlExpressions(db, sources) {
  *   A command that also builds a link index holds them already, and deriving
  *   them twice is the duplicated-corpus failure this closes.
  * @param {"all"|"public"} [opts.audience] - Whether to exclude GM notes.
+ * @param {Map<string, object>} [opts.foreignIndex] - The fetched indexes the
+ *   generated sections take in, where the caller holds them already; absent,
+ *   they are read from the cache.
  * @returns {Promise<Map<string, object[]>|undefined>} Results by note path,
  *   carrying `inline` and `pageLists` beside them, or nothing when the tree
- *   holds no such directive.
+ *   holds no such directive and no note is given a generated section.
  */
 export async function prepareTreeSqlTables(
     contentBase,
-    { config, skipDirectories, records, audience = "all" } = {},
+    { config, skipDirectories, records, audience = "all", foreignIndex } = {},
 ) {
     // Imported here rather than at module scope: the index reaches the pack
     // compilers through `manifest-emit` → `journals`, so a static import from a
@@ -745,20 +914,49 @@ export async function prepareTreeSqlTables(
         )
             sources.push({ source: absPath, markdown: body, frontmatter });
     }
-    if (!sources.length) return undefined;
+    // A note's event views are fences too, so a tree whose notes carry events
+    // asks a query even where no author wrote one.
+    const hasEvents = indexRecords.some(
+        (record) =>
+            isNoteRecord(record) &&
+            Array.isArray(record.data?.events) &&
+            record.data.events.length > 0,
+    );
+    // The derived lists read no database, so they are found before one is
+    // opened, and a tree whose notes are given only those opens none.
+    let foreign = foreignIndex;
+    if (!foreign) {
+        try {
+            const { loadForeignIndexes } = await import("./metadata-index.mjs");
+            foreign =
+                config ? loadForeignIndexes(config, [config.contentPackage]).index : new Map();
+        } catch {
+            foreign = new Map();
+        }
+    }
+    const derivedOnly = await generatedSectionsFor(undefined, indexRecords, contentBase, {
+        foreignIndex: foreign,
+        config,
+    });
+    if (!sources.length && !hasEvents && !derivedOnly.sections.size) return undefined;
 
     // A page list is a filter over the records, so it needs no database. A tree
     // whose only corpus-reading directive is one therefore opens none — which
     // is the same bargain the early return above makes for a tree with no
     // directive at all.
-    const needsDatabase = sources.some(
-        ({ markdown, frontmatter }) =>
-            findSqlBlocks(markdown).length || sqlQueriesInMarkdown(markdown, frontmatter).length,
-    );
+    const needsDatabase =
+        hasEvents ||
+        sources.some(
+            ({ markdown, frontmatter }) =>
+                findSqlBlocks(markdown).length ||
+                sqlQueriesInMarkdown(markdown, frontmatter).length,
+        );
     if (!needsDatabase) {
         const pageOnly = new Map();
+        joinGeneratedSections(derivedOnly, sources);
         pageOnly.inline = new Map();
         pageOnly.pageLists = preparePageLists(indexRecords, sources);
+        attachGeneratedSections(pageOnly, derivedOnly);
         return pageOnly;
     }
     // A cell links only where the address it would emit resolves, so a table
@@ -790,11 +988,16 @@ export async function prepareTreeSqlTables(
     }
     const db = await openNotesDatabase(indexRecords, { dependencies, audience });
     try {
+        const generated = await generatedSectionsFor(db, indexRecords, contentBase, {
+            derived: derivedOnly.derived,
+        });
+        joinGeneratedSections(generated, sources);
         const prepared = await prepareSqlTables(db, sources, {
             linkable: (ref) => addresses.has(renderAddress(ref)),
             records: indexRecords,
         });
         prepared.inline = await prepareInlineSqlExpressions(db, sources);
+        attachGeneratedSections(prepared, generated);
         return prepared;
     } finally {
         await db.close();

package/engine/standing-terms.mjs

@@ -1,4 +1,26 @@
-/* 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 terms of a body's standing — what a membership carries, and the rungs
+ * and posts a body confers — as inner-key declarations.
+ *
+ * A leaf module, importing nothing: the note vocabulary reads these
+ * declarations as it loads, and the checks that judge what the values mean
+ * reach the vocabulary through the Address reader.
+ *
+ * @module
+ */
 
 /**
  * The note type a standing is held in.
@@ -10,10 +32,127 @@
 export const STANDING_BODY_TYPES = Object.freeze(["affiliation"]);
 
 /**
- * The two keys one standing carries.
+ * The keys one standing carries, as inner-key declarations.
+ *
+ * `rank` is the level on the body's own `governance.ranks` ladder, and every
+ * membership states one. `office` is a key of its `governance.offices` map, and
+ * is stated only where the being holds a post.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const STANDING_FIELDS = Object.freeze([
+    Object.freeze({
+        name: "rank",
+        kind: "integer",
+        required: true,
+        shape:
+            "the level on that body's own ladder, as a whole number — an ordinary " +
+            "member is `1`, and `0` is the rung for someone cast out",
+        describe: "The level on the body's own `governance.ranks` ladder.",
+    }),
+    Object.freeze({
+        name: "office",
+        kind: "string",
+        shape: "a post from that body's `governance.offices`",
+        describe: "A post the body names in its `governance.offices`, where one is held.",
+    }),
+]);
+
+/** The keys of {@link STANDING_FIELDS}, in declared order. */
+export const STANDING_KEYS = Object.freeze(STANDING_FIELDS.map((field) => field.name));
+
+/**
+ * The keys a rung carries, as inner-key declarations.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const RUNG_FIELDS = Object.freeze([
+    Object.freeze({
+        name: "level",
+        kind: "integer",
+        required: true,
+        shape: "a whole number — the rung's position on this body's own ladder",
+        describe: "The rung's position on the ladder; a member's `rank` names it.",
+    }),
+    Object.freeze({
+        name: "title",
+        kind: "string",
+        required: true,
+        shape: "what the standing is called",
+        describe: "What the standing is called.",
+    }),
+    Object.freeze({
+        name: "description",
+        kind: "string",
+        required: true,
+        shape: "what the standing is",
+        describe: "What the standing is.",
+    }),
+    Object.freeze({
+        name: "lore",
+        kind: "address",
+        shape: "a lore Address",
+        describe: "Lore saying more about the standing than a description holds.",
+    }),
+]);
+
+/**
+ * The keys one row of an office's `holders` carries, as inner-key declarations.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const HOLDER_FIELDS = Object.freeze([
+    Object.freeze({
+        name: "being",
+        kind: "address",
+        required: true,
+        shape: "a being Address",
+        describe: "Who held the office.",
+    }),
+    Object.freeze({
+        name: "start",
+        kind: "date",
+        shape: "a date",
+        describe: "When the term began; unstated, it began before anything recorded.",
+    }),
+    Object.freeze({
+        name: "end",
+        kind: "date",
+        shape: "a date",
+        describe: "When the term ended; unstated, the being holds the office now.",
+    }),
+    Object.freeze({
+        name: "contested",
+        kind: "boolean",
+        shape: "`true` or `false`",
+        describe: "The term may overlap another holder's.",
+    }),
+]);
+
+/**
+ * The keys an office written as a map carries. An office may instead be its
+ * description alone, as a string.
  *
- * `rank` is the level on the body's own `governance.ranks` ladder, as a number.
- * `office` is a key of its `governance.offices` map, as a string. Both are
- * optional — a membership with neither is the ordinary shape.
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
-export const STANDING_KEYS = Object.freeze(["rank", "office"]);
+export const OFFICE_FIELDS = Object.freeze([
+    Object.freeze({
+        name: "description",
+        kind: "string",
+        required: true,
+        shape: "a string",
+        describe: "What the office is.",
+    }),
+    Object.freeze({
+        name: "holders",
+        kind: "list",
+        required: true,
+        shape: "a list of `{ being, start?, end?, contested? }`",
+        entries: Object.freeze({
+            kind: "map",
+            shape: "a map — `{ being, start?, end?, contested? }`",
+            fields: HOLDER_FIELDS,
+        }),
+        describe: "Who has held it, each with the dates of the term.",
+    }),
+]);

package/engine/standings.mjs

@@ -55,9 +55,10 @@ import { acceptsType, isAddressTuple, parseAddress, renderAddress } from "./addr
 import { AddressEntries } from "./address-values.mjs";
 import { slugify } from "./content-slug.mjs";
 import { positionOfFrontmatterPath } from "./diagnostics.mjs";
-import { STANDING_BODY_TYPES, STANDING_KEYS } from "./standing-terms.mjs";
+import { fitsKind } from "./data-keys.mjs";
+import { STANDING_BODY_TYPES, STANDING_FIELDS, STANDING_KEYS } from "./standing-terms.mjs";
 
-export { STANDING_BODY_TYPES, STANDING_KEYS };
+export { STANDING_BODY_TYPES, STANDING_FIELDS, STANDING_KEYS };
 
 /** Whether a value is a plain mapping. */
 function mapping(value) {
@@ -232,31 +233,35 @@ export function standingsDigest(fm) {
 }
 
 /**
- * How a standing reads beside the body that confers it.
+ * What a standing says before the body that confers it — `War Chief, Hárár
+ * (5), of ` — or `""` where no standing is held.
  *
  * The office leads, because it is the more particular of the two: a reader
- * meeting "War Chief" has been told the rung as well. The body closes the
- * phrase, which is the whole point of keying the entry by it — a standing with
- * no body named is the lossy form.
+ * meeting "War Chief" has been told the rung as well. The rung follows as its
+ * title with its level in parentheses, read from the body's own ladder; where
+ * the ladder names no rung at that level, or none is available, it reads as
+ * `Rank 5` and the number is not repeated. The body closes the phrase, which is
+ * the whole point of keying the entry by it — a standing with no body named is
+ * the lossy form.
  *
  * No article is supplied. One body's name reads with a "the" in front of it and
  * the next does not, and inventing one is this build editing the corpus.
  *
  * @param {object} standing - `{rank, office}`, either or both absent.
- * @param {string} body - What the body is called.
  * @param {{ranks?: Record<string, string>}} [digest] - The body's ladder.
- * @returns {string} The phrase, or the body's name where no standing is held.
+ * @returns {string} The words before the body's name, ending `of `.
  */
-export function standingPhrase(standing, body, digest) {
+export function standingLead(standing, digest) {
     const parts = [];
     if (typeof standing?.office === "string" && standing.office.trim())
         parts.push(standing.office.trim());
-    const level = Number(standing?.rank);
-    if (Number.isFinite(level)) {
+    const rank = standing?.rank;
+    const level = typeof rank === "number" || typeof rank === "string" ? Number(rank) : NaN;
+    if (rank !== "" && Number.isFinite(level)) {
         const title = digest?.ranks?.[String(level)];
-        parts.push(title ? title : `Rank ${level}`);
+        parts.push(title ? `${title} (${level})` : `Rank ${level}`);
     }
-    return parts.length ? `${parts.join(", ")}, of ${body}` : body;
+    return parts.length ? `${parts.join(", ")}, of ` : "";
 }
 
 /**
@@ -267,7 +272,8 @@ export function standingPhrase(standing, body, digest) {
  *
  * 1. the value is a map keyed by Address (or the list this window still takes);
  * 2. every key names an affiliation that resolves, once;
- * 3. the entry states a `rank`;
+ * 3. the entry states a standing at all — what a stated standing holds is the
+ *    inner-key check's, read from {@link STANDING_FIELDS};
  * 4. a `rank` is a level the named body's `governance.ranks` declares;
  * 5. an `office` is a key of that body's `governance.offices`.
  *
@@ -320,35 +326,20 @@ export function checkStandings(note, { index } = {}) {
         const named = resolved.address ?? String(body);
         // An entry with nothing after its key, and an emptied map arriving from
         // the property editor as `[]`, say exactly what an authored `{}` says:
-        // this being belongs to this body, and no standing in it is stated.
+        // this being belongs to this body, and no standing in it is stated. The
+        // inner-key check reads a map and has nothing to walk in either, so the
+        // absence is reported here.
         if (
             standing === undefined ||
             standing === null ||
             (Array.isArray(standing) && standing.length === 0)
         ) {
-            findings.push(...absentRankFindings(note, {}, named, path));
+            findings.push(...absentRankFindings(note, named, path));
             continue;
         }
-        if (!mapping(standing)) {
-            findings.push({
-                ...position(note, path),
-                message:
-                    `\`data.affiliations\` entry for ${named} must hold that body's standing ` +
-                    "as a map of `rank` and `office`, but reads " +
-                    JSON.stringify(standing),
-            });
-            continue;
-        }
-        for (const key of Object.keys(standing)) {
-            if (STANDING_KEYS.includes(key)) continue;
-            findings.push({
-                ...position(note, [...path, key], true),
-                message:
-                    `\`data.affiliations\` entry for ${named} has unknown key \`${key}\`; a ` +
-                    `standing holds ${STANDING_KEYS.map((name) => `\`${name}\``).join(" and ")}`,
-            });
-        }
-        findings.push(...absentRankFindings(note, standing, named, path));
+        // A standing of the wrong shape, an undeclared key and a missing `rank`
+        // are the inner-key check's findings, made from `STANDING_FIELDS`.
+        if (!mapping(standing)) continue;
         findings.push(...rankFindings(note, standing, named, path, resolved));
         findings.push(...officeFindings(note, standing, named, path, resolved));
     }
@@ -447,27 +438,22 @@ function bodyFindings(note, body, path, isKey, found) {
  * @param {Array<string|number>} path - The entry's frontmatter path.
  * @returns {object[]} The finding, or nothing.
  */
-function absentRankFindings(note, standing, body, path) {
-    if (standing.rank !== undefined && standing.rank !== null) return [];
-    const office = typeof standing.office === "string" ? standing.office.trim() : "";
+function absentRankFindings(note, body, path) {
     return [
         {
             ...position(note, path, true),
             message:
-                `\`data.affiliations\` entry for ${body} states no \`rank\`` +
-                (office ?
-                    `, and the office ${JSON.stringify(office)} is not one — an office ` +
-                    `distinguishes a person within a standing rather than standing in ` +
-                    `for one`
-                :   " — a being that belongs to a body holds some standing in it") +
-                ". An ordinary member is `1`, and `0` is the rung for someone cast out",
+                `\`data.affiliations\` entry for ${body} states no \`rank\` — a being ` +
+                "that belongs to a body holds some standing in it. An ordinary member " +
+                "is `1`, and `0` is the rung for someone cast out",
         },
     ];
 }
 
 /** Whether a `rank` is a rung the named body confers. */
 function rankFindings(note, standing, body, path, resolved) {
-    if (standing.rank === undefined || standing.rank === null) return [];
+    // Absent, or not a whole number: the inner-key check's finding.
+    if (!fitsKind(standing.rank ?? null, "integer")) return [];
     const at = position(note, [...path, "rank"]);
     const level = typeof standing.rank === "number" ? standing.rank : Number(standing.rank);
     if (typeof standing.rank !== "number" || !Number.isInteger(level))
@@ -504,9 +490,11 @@ function rankFindings(note, standing, body, path, resolved) {
 
 /** Whether an `office` is a post the named body names. */
 function officeFindings(note, standing, body, path, resolved) {
-    if (standing.office === undefined || standing.office === null) return [];
+    // Absent is a membership with no post; a value that is not text is the
+    // inner-key check's finding.
+    if (typeof standing.office !== "string") return [];
     const at = position(note, [...path, "office"]);
-    if (typeof standing.office !== "string" || !standing.office.trim())
+    if (!standing.office.trim())
         return [
             {
                 ...at,

package/engine/web-wikilinks.mjs

@@ -61,7 +61,13 @@ import { slugify } from "./content-slug.mjs";
 // resolution: the same rule that names a page also names an anchor within it.
 /** KB heading/anchor slug: lowercase, non-alphanumerics to single hyphens. */
 export { slugify };
-import { authoredLabel, WIKILINK, isSamePage, parseWikilink } from "./wikilink-syntax.mjs";
+import {
+    authoredLabel,
+    WIKILINK,
+    isEventAnchor,
+    isSamePage,
+    parseWikilink,
+} from "./wikilink-syntax.mjs";
 import { resolveEmbeds } from "./content-embeds.mjs";
 
 /**
@@ -424,6 +430,13 @@ export function resolveWebWikilinks(body, ctx) {
             // Checked against this page's own anchors, exactly as a link into
             // another page is: a self-link naming a section the page does not
             // declare is as dead as one naming a section nowhere does.
+            if (isEventAnchor(ctx, anchor)) {
+                return report(
+                    all,
+                    { target, reason: "event-anchor", anchor, addressed: true },
+                    label ?? anchor,
+                );
+            }
             if (!hasAnchor(ctx.anchors, anchor)) {
                 return report(
                     all,
@@ -459,6 +472,13 @@ export function resolveWebWikilinks(body, ctx) {
             // hash any slug into something that resolves, so an undeclared
             // one otherwise joins onto the URL unchecked and dead-ends for
             // the reader.
+            if (anchor && isEventAnchor(hit, anchor)) {
+                return report(
+                    all,
+                    { target, reason: "event-anchor", anchor, addressed: true },
+                    label ?? hit.name ?? target,
+                );
+            }
             if (anchor && hit.url && !hasAnchor(hit.anchors, anchor)) {
                 return report(
                     all,