@heroiclands/package-build 22.25.0 → 22.27.0

package/engine/populations.mjs

@@ -14,17 +14,14 @@
 /**
  * Whether a world's population figures agree from the region down.
  *
- * A place states `data.population` and an affiliation states how many people
- * it counts. Read across the whole corpus those figures make claims about each
- * other, and four of those claims can be checked: the bodies holding a region
- * fit inside it, the regions inside it fit inside it, a settlement fits inside
- * every place that contains it, and a page citing a figure states the figure
- * that note states.
- *
- * This is {@link module:engine/holdings}'s sibling and reads the same two
- * keys — a place's `data.parents` for geography, an affiliation's
- * `data.domains` for tenure. Where that module asks whether anybody holds a
- * place, this one asks whether the numbers add up.
+ * A place states `data.population` and an affiliation states its membership
+ * population. Three claims can be checked: the regions inside a place fit
+ * inside it, a settlement fits inside every place that contains it, and a page
+ * citing a figure states the figure that note states.
+ *
+ * Geography comes from a place's `data.parents`. Government is independent:
+ * an affiliation's membership population does not state the population of the
+ * territory it governs, so these checks do not compare the two.
  *
  * **Every finding is a warning.** A figure out of step with its neighbours is
  * a thing an author wants to see while the note is open, and the same gap can
@@ -39,10 +36,9 @@
  * **A stated figure is compared; an absent one is not.** A place or an
  * affiliation with no `population` contributes nothing to a sum and is never
  * the subject of a finding, so a half-written corpus is quiet rather than
- * noisy. A dependency's places and affiliations take part in the *structure* —
- * a fetched entry carries the `parents` and `domains` its record stated — and
- * a fetched index carries no figure, so a dependency's people are counted
- * nowhere.
+ * noisy. A dependency's places and affiliations take part when their fetched
+ * entry supplies a population figure; an older index without one contributes
+ * no population.
  *
  * **There is deliberately no urban-share rule.** A share computed from the
  * named settlements against a region's total measures nothing: the settlement
@@ -81,14 +77,6 @@ export const POPULATION_TOLERANCE = 1.05;
  * @type {ReadonlyArray<{name: string, describe: string}>}
  */
 export const POPULATION_RULES = Object.freeze([
-    Object.freeze({
-        name: "over-held land",
-        describe:
-            "The polities whose `domains` name a place count more people than the place " +
-            "states. A polity subordinate to another holding the same place is already " +
-            "counted in that polity's figure, and a settlement is exempt, its holder's " +
-            "figure counting a hinterland the settlement does not.",
-    }),
     Object.freeze({
         name: "over-full region",
         describe:
@@ -133,19 +121,16 @@ const CORPUS = new WeakMap();
  * @property {number} [population] The stated figure, absent where unstated.
  * @property {string[]} parents   A place's enclosing places, an affiliation's
  *                                superiors.
- * @property {string[]} domains   What an affiliation holds.
  */
 
 /**
- * The whole tree, indexed the three ways the rules read it.
+ * The whole tree, indexed by place, affiliation and geographical parent.
  *
  * @typedef {object} Corpus
  * @property {Map<string, PopulationNode>} places       By shortcode.
  * @property {Map<string, PopulationNode>} affiliations By shortcode.
  * @property {Map<string, string[]>} childrenOf   Place shortcode → the places
  *                                                whose `parents` name it.
- * @property {Map<string, string[]>} holdersOf    Place shortcode → the polities
- *                                                whose `domains` name it.
  * @property {Map<string, PopulationNode>} byAddress `type/shortcode` → the
  *                                                node, for the citation rule.
  *                                                Package-blind by design: a
@@ -210,7 +195,6 @@ function localNode(note) {
         title: String(fm.name?.full ?? shortcode),
         population: figureOf(data.population),
         parents: shortcodesOf(data.parents),
-        domains: type === "affiliation" ? shortcodesOf(data.domains) : [],
     };
 }
 
@@ -236,14 +220,13 @@ export function foreignNode(canonical, entry) {
         title: String(entry.name ?? shortcode),
         population: figureOf(entry.population),
         parents: shortcodesOf(entry.parents),
-        domains: type === "affiliation" ? shortcodesOf(entry.domains) : [],
     };
 }
 
 /**
  * The corpus a link index describes.
  *
- * Population containment and tenure use the same package-blind Shortcode
+ * Population containment uses the same package-blind Shortcode
  * identity as holdings and maps. Each type has one node per shortcode, with
  * local notes taking precedence over fetched entries. A fetched place can
  * attach to local geography, while its authored `parents` remains an Address.
@@ -289,18 +272,7 @@ function corpusOf(index) {
         }
     }
 
-    /** @type {Map<string, string[]>} */
-    const holdersOf = new Map();
-    for (const node of affiliations.values()) {
-        if (node.subType !== "polity") continue;
-        for (const domain of node.domains) {
-            const list = holdersOf.get(domain);
-            if (list) list.push(node.shortcode);
-            else holdersOf.set(domain, [node.shortcode]);
-        }
-    }
-
-    found = { places, affiliations, childrenOf, holdersOf, byAddress };
+    found = { places, affiliations, childrenOf, byAddress };
     CORPUS.set(index, found);
     return found;
 }
@@ -348,27 +320,6 @@ function ancestors(corpus, shortcode) {
     return out;
 }
 
-/**
- * The polities holding a place, each counted once.
- *
- * A polity subordinate to another polity that holds the same place is already
- * inside that polity's figure, so only the topmost of a chain counts.
- *
- * @param {Corpus} corpus - The corpus.
- * @param {string} shortcode - The place.
- * @returns {PopulationNode[]} The holders.
- */
-function topHolders(corpus, shortcode) {
-    const holders = corpus.holdersOf.get(shortcode) ?? [];
-    const held = new Set(holders);
-    return holders
-        .map((name) => corpus.affiliations.get(name))
-        .filter(
-            /** @returns {node is PopulationNode} */
-            (node) => Boolean(node) && !(node?.parents ?? []).some((p) => held.has(p)),
-        );
-}
-
 /**
  * The regions immediately inside a place.
  *
@@ -416,7 +367,7 @@ function atFigure(note, rule, message) {
  * runs it with the index every reference check resolves through. Without an
  * index the questions cannot be asked and nothing is reported.
  *
- * Three rules, each reported on the note being linted: `over-held land` and
+ * Two geographical rules, each reported on the note being linted:
  * `over-full region` on the place whose figure is exceeded, and
  * `oversized settlement` on the settlement that exceeds one.
  *
@@ -441,23 +392,6 @@ export function checkPopulation(note, { index } = {}) {
     const allowed = stated * POPULATION_TOLERANCE;
     const findings = [];
 
-    // A settlement is exempt: the polity holding a city-state counts the
-    // hinterland the city does not, so its figure is properly the larger.
-    if (subType !== "settlement") {
-        const holders = topHolders(corpus, shortcode);
-        const sum = holders.reduce((total, node) => total + (node.population ?? 0), 0);
-        if (sum > allowed) {
-            findings.push(
-                atFigure(
-                    note,
-                    "over-held land",
-                    `the polities holding ${title} count ${counted(sum)} people against its ` +
-                        `stated ${counted(stated)}`,
-                ),
-            );
-        }
-    }
-
     const regions = nearestRegions(corpus, shortcode);
     const inside = regions.reduce((total, node) => total + (node.population ?? 0), 0);
     if (inside > allowed) {
@@ -520,8 +454,8 @@ const CITED =
  * restated figures drift. Each is located at the figure it wrote, counting
  * repeats so two rows carrying one number land on their own lines.
  *
- * A citation naming a note this package does not hold is skipped: a fetched
- * index carries no figure, so there is nothing to disagree with.
+ * A citation naming a note with no published population figure is skipped:
+ * there is nothing to disagree with.
  *
  * Declared as the `doc` vocabulary's type-level check.
  *

package/engine/site-build.mjs

@@ -51,6 +51,7 @@
  * @module
  */
 
+import { renderAlerts, scanAlerts } from "./content-alerts.mjs";
 import { positionOfYamlPath } from "./diagnostics.mjs";
 import { decodeNoteAddresses, noteAddressContext, encodeAddresses } from "./note-addresses.mjs";
 import fs from "node:fs";
@@ -62,11 +63,12 @@ import { addressSlug } from "./content-address.mjs";
 import { protectCode } from "./code-fences.mjs";
 import { renderMarkdownExpressions } from "./markdown-expressions.mjs";
 import { expandContentTables } from "./content-tables.mjs";
+import { renderSpans, scanSpans } from "./content-spans.mjs";
 import { renderBlocks, renderWithheldSections, scanBlocks } from "./content-blocks.mjs";
 import { scanHeadingAttributes, withheldSections } from "./heading-attributes.mjs";
 import { renderFigureBlocks, scanFigures } from "./content-figures.mjs";
 import { footnoteFindings } from "./content-footnotes.mjs";
-import { collectAnchors } from "./anchors.mjs";
+import { collectAnchors, markupAnchorFindings } from "./anchors.mjs";
 import { checkImages, renderImageFigures } from "./content-images.mjs";
 import { assetPathnameKey, pathnameProblem, resolvePathname } from "./pathnames.mjs";
 import {
@@ -563,7 +565,7 @@ export function tableUniverse(pages) {
  * about every other page, known only once the whole tree has resolved — see
  * {@link module:engine/related-pages} — so an authored value is dropped the
  * way `aliases` is, and {@link renderPages} writes the derived block once it
- * holds the graph. `contains`, `held_by` and `holdings` are dropped for the
+ * holds the graph. Derived geographical and government lists are dropped for the
  * same reason — see {@link module:engine/holdings}. **So is `map`**: the
  * file a place page names is the one the build drew beside it — see
  * {@link module:engine/site-maps} — and a page with no drawing names none.
@@ -601,6 +603,7 @@ export function pageFrontmatter(page, { decorate, webSrc, artSrc }) {
         kbfolder: page.folder,
     };
     if (decorate) decorate(data, page);
+    if (data.type === "affiliation" && data.data) delete data.data.domains;
     delete data.aliases;
     delete data.related;
     for (const key of HOLDINGS_KEYS) delete data[key];
@@ -754,7 +757,7 @@ export function renderSitePage(
         return src;
     };
     const artSrc = (value, type, accepts) => artPathname(artIndex, value, type, accepts).pathname;
-    // The role lookup a `:::figure` fence's `map` counter reaches through —
+    // The role lookup a captioned item's `map` counter reaches through —
     // see `engine/content-figures.mjs`'s `resolveRole`. Addressed form, for
     // the page's own scan below, which runs before an embed is rewritten into
     // an ordinary image; `roleByWebSrc` is the same lookup keyed by the web
@@ -837,10 +840,14 @@ export function renderSitePage(
     });
     expressionErrors.push(...expressions.findings);
     const data = pageFrontmatter(page, { decorate, webSrc, artSrc });
-    const blocks = renderBlocks(protectCode(expressions.markdown, resolve), "web");
-    const figured = renderFigureBlocks(blocks.markdown, undefined, undefined, {
-        resolveRole: (address) => roleByWebSrc.get(address),
-    });
+    const figured = renderFigureBlocks(
+        protectCode(expressions.markdown, resolve),
+        undefined,
+        undefined,
+        {
+            resolveRole: (address) => roleByWebSrc.get(address),
+        },
+    );
     for (const error of figureScan.errors)
         captionErrors.push({
             file: page.file,
@@ -848,7 +855,12 @@ export function renderSitePage(
             column: error.column,
             message: error.message,
         });
-    for (const error of scanBlocks(page.body).errors)
+    for (const error of [
+        ...scanBlocks(page.body).errors,
+        ...scanAlerts(page.body).errors,
+        ...scanSpans(page.body).errors,
+        ...markupAnchorFindings(page.body),
+    ])
         secretErrors.push({
             file: page.file,
             line: (page.bodyLine ?? 1) + error.line - 1,
@@ -877,7 +889,10 @@ export function renderSitePage(
         // The disclosure is written last, over the Markdown the page ships: the
         // passes before this one carry line positions into their findings, and a
         // line inserted ahead of them would move every one of them.
-        body: renderWithheldSections(figured.markdown),
+        body: renderWithheldSections(
+            renderSpans(renderAlerts(renderBlocks(figured.markdown, "web").markdown).markdown)
+                .markdown,
+        ),
         data,
         resolved,
         tableErrors,
@@ -1053,13 +1068,26 @@ export function renderPages(pages, options) {
     }
 
     const related = relatedPages(edges, entries);
-    // What lies within a place, who holds it, and what an affiliation holds
-    // — read off `parents` and `domains` across this package and every
-    // fetched index, local notes first so they shadow a dependency's.
-    const holdings = holdingsPages([
-        ...pages.map((page) => holdingsNode(page.fm, { title: pageTitle(page), url: page.url })),
-        ...foreignHoldingsNodes(foreign?.index),
-    ]);
+    // Geography follows parents; governing-body lists follow explicit government
+    // references across this package and every fetched index.
+    const holdings = holdingsPages(
+        [
+            ...pages.map((page) =>
+                holdingsNode(page.fm, { title: pageTitle(page), url: page.url, package: page.pkg }),
+            ),
+            ...foreignHoldingsNodes(foreign?.index),
+        ],
+        {
+            governmentNodes: records
+                .filter((record) => !isGmNote(record))
+                .map((record) =>
+                    holdingsNode(record, {
+                        title: record.name?.full ?? record.shortcode,
+                        package: config?.contentPackage ?? pages[0]?.pkg,
+                    }),
+                ),
+        },
+    );
 
     let withMap = 0;
     const outputs = capture === true ? new Map() : null;

package/engine/site-preview.mjs

@@ -284,12 +284,28 @@ export async function prepareSitePreview({ config = loadPackConfig() } = {}) {
                 });
                 const related = relatedPages(edges, entries).get(page.url);
                 if (related) result.data.related = related;
-                const holdings = holdingsPages([
-                    ...allPages.map((item) =>
-                        holdingsNode(item.fm, { title: item.name, url: item.url }),
-                    ),
-                    ...foreignHoldingsNodes(snapshot.gates.foreign.index),
-                ]);
+                const holdings = holdingsPages(
+                    [
+                        ...allPages.map((item) =>
+                            holdingsNode(item.fm, {
+                                title: item.name,
+                                url: item.url,
+                                package: item.pkg ?? config.contentPackage,
+                            }),
+                        ),
+                        ...foreignHoldingsNodes(snapshot.gates.foreign.index),
+                    ],
+                    {
+                        governmentNodes: records
+                            .filter((record) => !isGmNote(record))
+                            .map((record) =>
+                                holdingsNode(record, {
+                                    title: record.name?.full ?? record.shortcode,
+                                    package: config.contentPackage,
+                                }),
+                            ),
+                    },
+                );
                 Object.assign(result.data, holdings.get(page.url));
                 return {
                     ok: true,

package/engine/wikilinks.mjs

@@ -100,7 +100,8 @@ export function anchorPageId(noteId, anchorSlug) {
  *
  * @param {Array<{type: string, id: string, shortcode?: string|null,
  *   name?: string, pack?: string, docPack?: string, none?: boolean,
- *   draft?: boolean}>} docs -
+ *   draft?: boolean, anchors?: Set<string>, anchorUuids?: Record<string,string>,
+ *   docAnchorUuids?: Record<string,string>}>} docs -
  *   One entry per content note. `pack` / `docPack` name the packs the note's
  *   document and its documentation entry landed in; omitted, the conventional
  *   one-pack-per-type names stand in. `none` says the note declares
@@ -153,9 +154,11 @@ export function buildWikilinkIndex(
     // that stored value. Nothing downstream assembles a UUID from parts, so a
     // link and its target cannot disagree about where the document lives.
     const uuidByDoc = new Map();
+    const byId = new Map();
 
     for (const d of docs) {
         if (!d.id || !d.type) continue;
+        byId.set(`${d.type}/${d.id}`, d);
         types.add(norm(d.type));
 
         uuidByDoc.set(
@@ -172,6 +175,8 @@ export function buildWikilinkIndex(
                     // type and a UUID carries the pack name, so the address
                     // cannot be derived from the type alone.
                     uuid: compendiumUuid(packageId, d.type, d.id, d.pack),
+                    anchors: d.anchorUuids,
+                    docAnchors: d.docAnchorUuids,
                     // The readable note has a separate JournalEntry whose id
                     // is derived from the item's id.
                     docUuid: compendiumUuid(packageId, "doc", itemDocEntryId(d.id), d.docPack),
@@ -216,6 +221,7 @@ export function buildWikilinkIndex(
         foreignReferences,
         types,
         uuidByDoc,
+        byId,
         packageId,
         /** The content package this build publishes, which an art address defaults to. */
         contentPackage: contentPackage ?? packageId,
@@ -433,7 +439,7 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index, cap
         // Kept for the foreign fallback below, which needs the parsed address.
         let qualifiedRead = null;
         if (target === "" && slug) {
-            doc = { type, id, pack, docPack };
+            doc = index.byId?.get(`${type}/${id}`) ?? { type, id, pack, docPack };
         } else {
             const qualified = parsed.problem ?? parsed.target;
             qualifiedRead = qualified;
@@ -546,7 +552,13 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index, cap
         // reader. A foreign anchor has always been checked this way —
         // the manifest carries the map — and a local one now is too, from the
         // anchor set the index carries.
-        if (slug && isJournal && doc.anchors && !doc.anchors.has(slug)) {
+        const anchorUuids = itemDoc ? addresses.docAnchors : addresses.anchors;
+        if (
+            slug &&
+            isJournal &&
+            ((doc.anchors && !doc.anchors.has(slug)) ||
+                (anchorUuids && !Object.hasOwn(anchorUuids, slug)))
+        ) {
             unresolved.push({
                 link: all,
                 target,
@@ -558,7 +570,9 @@ export function convertWikilinks(markdown, { type, id, pack, docPack, index, cap
             return unresolvedLink(text || doc.name || target, target);
         }
         const uuid =
-            slug && isJournal ? pageUuid(entryUuid, anchorPageId(entryId, slug)) : entryUuid;
+            slug && isJournal ?
+                (anchorUuids?.[slug] ?? pageUuid(entryUuid, anchorPageId(entryId, slug)))
+            :   entryUuid;
         const link = `@UUID[${uuid}]{${text}}`;
         // A link into a note that exists but is not written renders marked.
         // Presentation only — the UUID above is unchanged, and a

package/hugo-theme/layouts/partials/holdings/entry.html

@@ -1,7 +1,7 @@
 {{- /*
   One entry of a holdings list — `{title, url, type, subType}`, as
-  `@heroiclands/package-build` derives from `contains`, `held_by` and
-  `holdings` (see the "holdings card" section of the README).
+  `@heroiclands/package-build` derives from `contains`, `governed_by` and
+  `governed_places` (see the "holdings card" section of the README).
 
   `url` is absent for a stub: a note with an empty body, which carries its
   facts into every list that names it but publishes no page of its own. The

package/hugo-theme/layouts/partials/holdings.html

@@ -1,22 +1,22 @@
 {{- /*
-  Holdings card.
+  Geography and government card.
 
   Three small tables, rendered after the body and before the Related card
   (see `page-body.html`), from front matter `@heroiclands/package-build`
   derives and a note never authors itself:
 
     contains:  [{ title, url, type, subType }]  places sitting within this one
-    held_by:   [{ title, url, type, subType }]  affiliations holding this place
-    holdings:  [{ title, url, type, subType }]  places this affiliation holds
+    governed_by:   [{ title, url, type, subType }]  affiliations governing this place
+    governed_places:  [{ title, url, type, subType }]  places this affiliation governs
 
-  A place page carries `contains` and/or `held_by`; an affiliation page
-  carries `holdings`. Neither is checked here — presence of the key is the
+  A place page carries `contains` and/or `governed_by`; an affiliation page
+  carries `governed_places`. Neither is checked here — presence of the key is the
   only test, the same silent-disappear convention the Related card follows:
   a page carrying none of the three renders no card at all.
 
-  `contains` and `holdings` list places, so each is broken into groups by
+  `contains` and `governed_places` list places, so each is broken into groups by
   kind (`holdings/kind-groups.html`) — the towns together, the hamlets
-  together. `held_by` lists affiliations, whose kinds have no fixed
+  together. `governed_by` lists affiliations, whose kinds have no fixed
   hierarchy to group by, so it stays one flat grid with the kind printed
   beside each name instead of as a group heading.
 
@@ -27,10 +27,10 @@
   was established.
 */ -}}
 {{- $within := .Params.contains -}}
-{{- $heldBy := .Params.held_by -}}
-{{- $holds := .Params.holdings -}}
+{{- $government := .Params.governed_by -}}
+{{- $governed := .Params.governed_places -}}
 
-{{- if or $within $heldBy $holds -}}
+{{- if or $within $government $governed -}}
 <section class="holdings" data-pagefind-ignore>
   {{- with $within }}
   <div class="holdings-table">
@@ -38,9 +38,9 @@
     {{ partial "holdings/kind-groups.html" . }}
   </div>
   {{- end }}
-  {{- with $heldBy }}
+  {{- with $government }}
   <div class="holdings-table">
-    <h3 class="holdings-table-label">Held by</h3>
+    <h3 class="holdings-table-label">Governed by</h3>
     <ul class="holdings-table-grid">
       {{- range . }}
       <li>
@@ -51,9 +51,9 @@
     </ul>
   </div>
   {{- end }}
-  {{- with $holds }}
+  {{- with $governed }}
   <div class="holdings-table">
-    <h3 class="holdings-table-label">Holdings</h3>
+    <h3 class="holdings-table-label">Governed places</h3>
     {{ partial "holdings/kind-groups.html" . }}
   </div>
   {{- end }}

package/hugo-theme/static/css/style.css

@@ -2868,9 +2868,9 @@ summary.info-sidebar-title::after {
    group's entries laid out as a CSS grid that reflows its own column count
    from the available width — two or three columns on a desktop, one on a
    phone — with no breakpoint needed. Related groups by the connected page's
-   `type`; Holdings groups `contains` and `holdings` by place `subType`
+   `type`; Holdings groups `contains` and `governed_places` by place `subType`
    (`.holdings-kind-group`, one level deeper, for the region/settlement/site
-   hierarchy) and leaves `held_by` a flat grid with the kind printed beside
+   hierarchy) and leaves `governed_by` a flat grid with the kind printed beside
    each name. */
 
 .related,
@@ -2980,3 +2980,41 @@ summary.info-sidebar-title::after {
     padding: 1.25rem 1.25rem;
   }
 }
+
+/* GitHub-style author alerts remain open and inherit the prose foreground. */
+.single-content .alert {
+  border-inline-start: 0.25rem solid var(--pb-alert-color);
+  padding: 0.5rem 1rem;
+  margin: 1rem 0;
+  color: inherit;
+  background: transparent;
+}
+.single-content .alert-title {
+  display: flex;
+  align-items: center;
+  gap: 0.5em;
+  margin: 0 0 0.5rem;
+  font-weight: 600;
+  color: var(--pb-alert-color);
+}
+.single-content .alert-icon {
+  width: 1em;
+  height: 1em;
+  flex-shrink: 0;
+  fill: currentColor;
+}
+.single-content .alert > :last-child {
+  margin-bottom: 0;
+}
+.single-content .alert-note {
+  --pb-alert-color: #4493f8;
+}
+.single-content .alert-tip {
+  --pb-alert-color: #3fb950;
+}
+.single-content .alert-important {
+  --pb-alert-color: #ab7df8;
+}
+.single-content .alert-warning {
+  --pb-alert-color: #d29922;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "22.25.0",
+    "version": "22.27.0",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",

package/sohl/item-fields.mjs

@@ -449,22 +449,6 @@ export const ITEM_FIELDS = Object.freeze({
             default: null,
             describe: "Where the affiliation's authority sits, by place address.",
         },
-        {
-            // The geographic relation, kept apart from the organisational one
-            // above: `parents` is *subordinate to*, this is *holds sway over*.
-            //
-            // Authored plural and emitted singular, as the content format's
-            // mapping row states (`data.domains` → `system.domain`). The two
-            // spellings are deliberate rather than a slip, so the declaration
-            // carries both rather than either side guessing.
-            name: "data.domains",
-            legacyKey: "domains",
-            to: "domain",
-            ...ADDRESS_LIST,
-            address: PLACE_ITEMS,
-            default: [],
-            describe: "Places this affiliation holds sway over, by address.",
-        },
     ]),
 
     affliction: Object.freeze([

package/types/engine/anchors.d.mts

@@ -1,9 +1,8 @@
 /**
- * The `{#slug}` and `:::figure {#slug}` anchors a note declares.
+ * The identifiers a note declares on headings, captions, divs, poems and spans.
  *
- * A bare `#` heading starts a journal page without declaring a slug, and so
- * does a figure fence that declares no id. A fence that declares one declares a
- * slug and starts an addressable journal page.
+ * Headings and captions may start journal pages. Div, poem and inline-span
+ * anchors address locations within their containing pages.
  *
  * @param {string} body - The note's markdown body, frontmatter already removed.
  * @param {number} [bodyLine] - The 1-based file line the body starts on, from
@@ -22,3 +21,13 @@ export function collectAnchors(body: string, bodyLine?: number, resolveRole?: (a
     level: number;
     line: number;
 }>;
+/** Collisions involving a div, verse or inline-span anchor.
+ * Heading and caption collisions are diagnosed by their existing scanners.
+ * @param {string} body - Authored Markdown.
+ * @returns {Array<{line: number, column: number, message: string}>} Located collisions.
+ */
+export function markupAnchorFindings(body: string): Array<{
+    line: number;
+    column: number;
+    message: string;
+}>;

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

@@ -144,7 +144,7 @@ export function resolveArtRecord(index: object, value: unknown, defaultType: str
  * carries once an embed's address has been rewritten into the ordinary image
  * every surface renders ({@link module:engine/content-embeds.resolveEmbeds}).
  *
- * This is the lookup a `:::figure` fence's `map` counter reaches through —
+ * This is the lookup a captioned item's `map` counter reaches through —
  * see {@link module:engine/content-figures.scanFigures}'s `resolveRole` —
  * for a caller that reads a body after that rewrite: a Foundry journal, an
  * item or actor's documentation, and the book.

package/types/engine/calendar-notes.d.mts

@@ -29,7 +29,7 @@ export function checkCalendarDateFormats(note: any): {
 /**
  * Check a `place` note's world facts.
  *
- * Declared on `place` beside its tenure check, so the lint runs both with the
+ * Declared on `place` beside its government advisory, so the lint runs both with the
  * same index. Four rules, and each is a fact about the setting rather than
  * about the file:
  *

package/types/engine/code-fences.d.mts

@@ -17,11 +17,13 @@ export function parseHeaderArgs(info: string): {
  * @param {object} [options]
  * @param {boolean} [options.spans=true] - Include inline code spans. Set false
  *   to consider only block-level code.
+ * @param {boolean} [options.poetryAsProse=true] - Treat verse bodies as inline prose.
  * @returns {Array<{start: number, end: number}>} Non-overlapping regions, in
  *   source order. `end` is exclusive.
  */
-export function codeRegions(markdown: string | null | undefined, { spans }?: {
+export function codeRegions(markdown: string | null | undefined, { spans, poetryAsProse }?: {
     spans?: boolean | undefined;
+    poetryAsProse?: boolean | undefined;
 }): Array<{
     start: number;
     end: number;