@heroiclands/package-build 22.28.0 → 23.1.0

package/types/engine/note-event-terms.d.mts

@@ -0,0 +1,68 @@
+/**
+ * The **terms of an event**: the closed value lists an event entry draws on,
+ * and the declaration of every key an entry and each map inside it take.
+ *
+ * A leaf module, importing nothing. The note vocabulary reads
+ * {@link EVENT_ENTRY} as it loads, so the frontmatter lint's inner-key check
+ * closes every key of an entry the way it closes every other `data:` field's;
+ * {@link module:engine/note-events} walks the same declaration for what the
+ * values mean — closed lists, Addresses, identity and order — and reaches the
+ * vocabulary through the Address reader.
+ *
+ * An entry is declared in the inner-key vocabulary of
+ * {@link module:engine/data-keys} — `fields`, `entries`, `kind`, `shape`,
+ * `required`, `describe` — with four properties of its own that the event
+ * check reads:
+ *
+ * - `oneOf` — `{name, values}`: the value is one of `values`, a closed list the
+ *   format reference states as the vocabulary table `name`;
+ * - `ref`, `accepts`, `anchors`, `single`, `eventOrLore`, `calendar` on an
+ *   Address: its default type, its accepted types, the anchor kinds it may
+ *   name, and whether it must name exactly one event, an event or a `lore`
+ *   note, or a calendar note;
+ * - `own` — the key's value is judged by the event check's own code (`id`,
+ *   `when`, `until`, `recurs`) rather than by the walker.
+ *
+ * @module
+ */
+/** What an event is, grouped for reading and closed for validation. */
+export const EVENT_KINDS: readonly string[];
+/** How far an event's history reaches. Set by hand. */
+export const EVENT_DEPTHS: readonly string[];
+/** What the world's evidence supports about an event. */
+export const EVENT_STANDINGS: readonly string[];
+/** Whether a place that felt an event knows what caused it. */
+export const REACH_KNOWLEDGE: readonly string[];
+/** What a participant was to an event. */
+export const PARTICIPANT_ROLES: readonly string[];
+/** How a later event follows from an earlier one. */
+export const FOLLOWS_HOW: readonly string[];
+/** How far an account agrees with the event's summary. */
+export const ACCOUNT_AGREES: readonly string[];
+/**
+ * Every closed list, by the name of the vocabulary table the format reference
+ * and `engine/content-format.yaml` state it under. `eventKind` is not `kind`
+ * because the infobox's row kinds already hold that name.
+ */
+export const EVENT_VOCABULARIES: Readonly<{
+    eventKind: readonly string[];
+    depth: readonly string[];
+    standing: readonly string[];
+    knowledge: readonly string[];
+    role: readonly string[];
+    followsHow: readonly string[];
+    agrees: readonly string[];
+}>;
+/**
+ * One event entry, as an inner-key declaration: every key it takes, and every
+ * key of each map nested in it.
+ *
+ * @type {Readonly<{kind: "map", shape: string, fields: readonly object[]}>}
+ */
+export const EVENT_ENTRY: Readonly<{
+    kind: "map";
+    shape: string;
+    fields: readonly object[];
+}>;
+/** Every key an event entry admits, in the order the reference documents them. */
+export const EVENT_ENTRY_KEYS: any;

package/types/engine/note-events.d.mts

@@ -0,0 +1,71 @@
+/**
+ * Resolve an Address a field outside an event writes to name one — a gear
+ * note's `made` or a literature note's `subjects` entry — by the rules an
+ * event's own `follows` is resolved by.
+ *
+ * @param {unknown} value - The authored value: a string, a tuple, or an
+ *   {@link AddressLink}.
+ * @param {{ref?: string, accepts?: readonly string[], anchors?: readonly string[],
+ *   single?: boolean}} spec - The field's declaration: `ref` the default type of
+ *   a bare shortcode, `accepts` the types the Address may name, `anchors` the
+ *   anchor kinds `#<anchor>` may name, and `single` whether it must name exactly
+ *   one event.
+ * @param {object} index - The link index.
+ * @returns {{problem?: string, hit?: object, position?: number, target?: string}}
+ *   What it names, or why it names nothing.
+ */
+export function resolveEventReference(value: unknown, spec: {
+    ref?: string;
+    accepts?: readonly string[];
+    anchors?: readonly string[];
+    single?: boolean;
+}, index: object): {
+    problem?: string;
+    hit?: object;
+    position?: number;
+    target?: string;
+};
+/**
+ * Validate a note's `data.events`, entry by entry.
+ *
+ * Registered as the `events` field's `check`, so it runs on every note whose
+ * type declares `events`, whatever its `subType`. Without an index the shape,
+ * the closed values, the identity and the dates are checked and no Address is
+ * resolved.
+ *
+ * @param {object} note - The note, as the link index hands it over.
+ * @param {{index?: object}} [options]
+ * @returns {object[]} Findings, each positioned at the key or value that
+ *   earned it.
+ */
+export function checkNoteEvents(note: object, { index }?: {
+    index?: object;
+}): object[];
+/**
+ * Every Address position inside one event entry, derived from the schema
+ * above: its path from the entry (`*` for each list item), whether it holds one
+ * Address or a list of them, and its default type, accepted types and anchor
+ * kinds. The note boundary reads these Addresses into tuples, so the published
+ * index writes them as it writes every other Address.
+ *
+ * @type {ReadonlyArray<{path: readonly string[], shape: "value"|"list",
+ *   type?: string, accepts?: readonly string[], anchors?: readonly string[]}>}
+ */
+export const EVENT_ADDRESS_POSITIONS: ReadonlyArray<{
+    path: readonly string[];
+    shape: "value" | "list";
+    type?: string;
+    accepts?: readonly string[];
+    anchors?: readonly string[];
+}>;
+import { ACCOUNT_AGREES } from "./note-event-terms.mjs";
+import { EVENT_DEPTHS } from "./note-event-terms.mjs";
+import { EVENT_ENTRY } from "./note-event-terms.mjs";
+import { EVENT_ENTRY_KEYS } from "./note-event-terms.mjs";
+import { EVENT_KINDS } from "./note-event-terms.mjs";
+import { EVENT_STANDINGS } from "./note-event-terms.mjs";
+import { EVENT_VOCABULARIES } from "./note-event-terms.mjs";
+import { FOLLOWS_HOW } from "./note-event-terms.mjs";
+import { PARTICIPANT_ROLES } from "./note-event-terms.mjs";
+import { REACH_KNOWLEDGE } from "./note-event-terms.mjs";
+export { ACCOUNT_AGREES, EVENT_DEPTHS, EVENT_ENTRY, EVENT_ENTRY_KEYS, EVENT_KINDS, EVENT_STANDINGS, EVENT_VOCABULARIES, FOLLOWS_HOW, PARTICIPANT_ROLES, REACH_KNOWLEDGE };

package/types/engine/note-vocabulary.d.mts

@@ -134,14 +134,18 @@ export function dataFields(type: string, vocabulary?: Readonly<Record<string, Ty
  */
 export function subTypes(type: string, vocabulary?: Readonly<Record<string, TypeVocabulary>>): readonly string[] | null | undefined;
 /**
- * Accepted migration input with no canonical field or emitted value.
+ * What happened to or at a subject — the `events` key, declared once and spread
+ * into every type that carries events, so the schema cannot differ between
+ * them. The entry's own schema and its check live in
+ * {@link module:engine/note-events}.
  *
- * Legacy affiliation domains are ignored. They never supply a government.
- * @param {string} type - The note type.
- * @param {string} key - An authored data key.
- * @returns {boolean} Whether the obsolete key is accepted during migration.
+ * Declared here rather than in that module because its imports reach back to
+ * this one: a function declaration is bound before either module runs, and an
+ * object is not.
+ *
+ * @type {DataFieldSpec}
  */
-export function isLegacyDataField(type: string, key: string): boolean;
+export const EVENTS_FIELD: DataFieldSpec;
 /**
  * One top-level frontmatter key.
  *
@@ -389,6 +393,16 @@ export type DataFieldSpec = {
      * - Allowed Address types, separate from `ref`.
      */
     accepts?: readonly string[] | undefined;
+    /**
+     * - The anchor kinds an
+     * Address here may name with `#<anchor>`. Absent, an anchor is refused.
+     */
+    anchors?: readonly ("event" | "prose")[] | undefined;
+    /**
+     * - The Address names exactly one event: an
+     * anchor of kind `event`, or a note holding one event and no more.
+     */
+    single?: boolean | undefined;
     /**
      * - Infobox text for an explicitly authored null with a declared meaning.
      */
@@ -407,8 +421,7 @@ export type DataFieldSpec = {
     entryShape?: string | undefined;
     /**
      * - The Address's default type, an art slot declares
-     * one — `icon` for `icon` and `tokenIcon`, `image` for `bgImage` and
-     * `banner` — so `icon: anvil` names `icon-anvil` while a value carrying the
+     * one — `icon` for `icon` and `tokenIcon`, `image` for `banner` — so `icon: anvil` names `icon-anvil` while a value carrying the
      * separator states its own address. Distinct from a `FieldSpec`'s `code`
      * ({@link module :engine/field-spec}), which names a **Shortcode** instead.
      */
@@ -431,6 +444,22 @@ export type DataFieldSpec = {
     check?: ((note: object, opts: {
         index?: object;
     }) => object[]) | undefined;
+    /**
+     * - The
+     * keys of a value that is a map, closed to them — see
+     * {@link module :engine/data-keys}.
+     */
+    fields?: readonly import("./data-keys.mjs").InnerKeySpec[] | undefined;
+    /**
+     * - What one entry of a list value is, where the
+     * entries are not Addresses (`entryKind` says that).
+     */
+    entries?: object | undefined;
+    /**
+     * - What the value under each key of a keyed map
+     * is, where the keys are data rather than declared names.
+     */
+    values?: object | undefined;
     /**
      * - One line, for the author-facing reference.
      */

package/types/engine/office-holders.d.mts

@@ -12,3 +12,6 @@ export function checkDatedOffices(note: object, { index }?: {
     column?: number;
     file: any;
 }[];
+import { HOLDER_FIELDS } from "./standing-terms.mjs";
+import { OFFICE_FIELDS } from "./standing-terms.mjs";
+export { HOLDER_FIELDS, OFFICE_FIELDS };

package/types/engine/pdf-index.d.mts

@@ -0,0 +1,35 @@
+/**
+ * The marker an entry heading or an authored mention carries.
+ *
+ * @param {string} slug - The address slug of the note the marker is about.
+ * @param {boolean} [main] - Whether this is the note's own entry.
+ * @returns {string} Typst markup occupying no space.
+ */
+export function indexMarker(slug: string, main?: boolean): string;
+/**
+ * Every term the book's index lists, in index order.
+ *
+ * @param {object[]} entries - The plan's entries.
+ * @returns {Array<{letter: string, name: string, slug: string, see?: string}>}
+ *   Terms with `see` set for a cross-reference to the main name it points at.
+ */
+export function indexTerms(entries: object[]): Array<{
+    letter: string;
+    name: string;
+    slug: string;
+    see?: string;
+}>;
+/**
+ * The Typst function definitions the markers and the chapter rely on.
+ *
+ * @returns {string} Typst source.
+ */
+export function indexPreamble(): string;
+/**
+ * The index chapter, ready to follow the last entry.
+ *
+ * @param {object[]} entries - The plan's entries.
+ * @param {string} title - The book's title, which kicks the chapter.
+ * @returns {string} Typst source, or "" when the book has nothing to index.
+ */
+export function indexChapter(entries: object[], title: string): string;

package/types/engine/pdf-render.d.mts

@@ -99,6 +99,10 @@ export function stripHtmlComments(markdown: string): string;
  *   at. Every link the book sets as a URL is resolved against it, because a
  *   reader holding a PDF has no page to resolve a path against — see
  *   {@link renderLink}.
+ * @param {boolean} [opts.generated] - Whether the Markdown is a note's
+ *   generated sections rather than its author's text — see
+ *   {@link module:engine/generated-sections}. Their links follow the rules
+ *   {@link renderLink} states for generated links.
  * @returns {string} Typst markup.
  */
 export function markdownToTypst(markdown: string, opts?: {
@@ -125,6 +129,7 @@ export function markdownToTypst(markdown: string, opts?: {
     }[] | undefined;
     prepared?: boolean | undefined;
     url?: string | undefined;
+    generated?: boolean | undefined;
 }): string;
 /**
  * A page address as a reader of the book can follow it.
@@ -325,8 +330,9 @@ export function renderBook({ plan, bodies, title, subtitle, front, fonts, versio
  * that would have contained it, which is where a reader wants to end up anyway;
  * a link with no entry to fall back to becomes plain text. Both are reported.
  *
- * A declaration is a label not preceded by `#link(` — the only two places a
- * label appears are the heading that declares one and the link that uses one.
+ * A declaration is a label preceded by neither `#link(` nor `locate(` — a
+ * label appears in the heading that declares it, the link that uses it, and
+ * the page lookup a generated link prints after itself.
  *
  * @param {string} source - The assembled Typst document.
  * @param {object[]} [findings] - Collected here rather than thrown.

package/types/engine/place-relation-terms.d.mts

@@ -0,0 +1,83 @@
+/**
+ * The closed sets a place's `borders` and `routes` are held to, and the keys
+ * one entry of each carries.
+ *
+ * A leaf module, importing nothing: the note vocabulary reads the entry
+ * declarations as it loads, and {@link module:engine/place-relations}, which
+ * checks what the values mean, reaches the vocabulary through the Address
+ * reader.
+ *
+ * @module
+ */
+/**
+ * The type a border's or a route's `to` names.
+ *
+ * It is both the default its `<type>` segment takes when an author omits it and
+ * the whole of the set the position accepts, which is what makes `vylar` and
+ * `place-vylar` the same Address and a `to` naming a `lore` note an error rather
+ * than a lookup that quietly finds nothing.
+ *
+ * @type {string}
+ */
+export const RELATION_TYPE: string;
+/**
+ * The eight compass bearings, clockwise from north.
+ *
+ * Where a neighbour or a destination lies from the place stating it. The
+ * order is load-bearing: {@link oppositeBearing} reads four steps around it.
+ *
+ * @type {readonly string[]}
+ */
+export const BEARINGS: readonly string[];
+/**
+ * The modes a route is travelled by: `land`, `boat` on a river or a lake,
+ * `ship` on open sea.
+ *
+ * @type {readonly string[]}
+ */
+export const ROUTE_MODES: readonly string[];
+/**
+ * The days markers a route may state.
+ *
+ * Each is "about this, under normal conditions": `10`, `20` and `30` are one,
+ * two and three ten-day weeks, `180` is many months, `360` is "who knows".
+ *
+ * @type {readonly number[]}
+ */
+export const TRAVEL_DAYS: readonly number[];
+/**
+ * The terrain registry, each terrain naming the modes that cross it.
+ *
+ * A land terrain is crossed by land alone; open sea by ship; a river or a lake
+ * by boat; a coast by all three, because a coast road and a coasting voyage
+ * are both journeys along it.
+ *
+ * @type {Readonly<Record<string, readonly string[]>>}
+ */
+export const TERRAIN_MODES: Readonly<Record<string, readonly string[]>>;
+/**
+ * The terrain names, in registry order — the closed set a `terrain` list
+ * draws from.
+ *
+ * @type {readonly string[]}
+ */
+export const TERRAINS: readonly string[];
+/**
+ * The keys a `borders` entry carries, as inner-key declarations. Both are
+ * required.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const BORDER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys a `routes` entry carries, as inner-key declarations. `to`,
+ * `bearing`, `mode` and `days` are required; `terrain` and `leagues` are
+ * optional.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const ROUTE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/** The keys a `borders` entry carries. @type {readonly string[]} */
+export const BORDER_KEYS: readonly string[];
+/** The keys a `routes` entry carries. @type {readonly string[]} */
+export const ROUTE_KEYS: readonly string[];

package/types/engine/place-relations.d.mts

@@ -38,69 +38,14 @@ export function checkBorders(note: object, { index }?: {
 export function checkRoutes(note: object, { index }?: {
     index?: object | undefined;
 }): object[];
-/**
- * The type a border's or a route's `to` names.
- *
- * It is both the default its `<type>` segment takes when an author omits it and
- * the whole of the set the position accepts, which is what makes `vylar` and
- * `place-vylar` the same Address and a `to` naming a `lore` note an error rather
- * than a lookup that quietly finds nothing.
- *
- * @type {string}
- */
-export const RELATION_TYPE: string;
-/**
- * The eight compass bearings, clockwise from north.
- *
- * Where a neighbour or a destination lies from the place stating it. The
- * order is load-bearing: {@link oppositeBearing} reads four steps around it.
- *
- * @type {readonly string[]}
- */
-export const BEARINGS: readonly string[];
-/**
- * The modes a route is travelled by: `land`, `boat` on a river or a lake,
- * `ship` on open sea.
- *
- * @type {readonly string[]}
- */
-export const ROUTE_MODES: readonly string[];
-/**
- * The days markers a route may state.
- *
- * Each is "about this, under normal conditions": `10`, `20` and `30` are one,
- * two and three ten-day weeks, `180` is many months, `360` is "who knows".
- *
- * @type {readonly number[]}
- */
-export const TRAVEL_DAYS: readonly number[];
-/**
- * The terrain registry, each terrain naming the modes that cross it.
- *
- * A land terrain is crossed by land alone; open sea by ship; a river or a lake
- * by boat; a coast by all three, because a coast road and a coasting voyage
- * are both journeys along it.
- *
- * @type {Readonly<Record<string, readonly string[]>>}
- */
-export const TERRAIN_MODES: Readonly<Record<string, readonly string[]>>;
-/**
- * The terrain names, in registry order — the closed set a `terrain` list
- * draws from.
- *
- * @type {readonly string[]}
- */
-export const TERRAINS: readonly string[];
-/**
- * The keys a `borders` entry may carry. Both are required.
- *
- * @type {readonly string[]}
- */
-export const BORDER_KEYS: readonly string[];
-/**
- * The keys a `routes` entry may carry. `to`, `bearing`, `mode` and `days` are
- * required; `terrain` and `leagues` are optional.
- *
- * @type {readonly string[]}
- */
-export const ROUTE_KEYS: readonly string[];
+import { RELATION_TYPE } from "./place-relation-terms.mjs";
+import { BEARINGS } from "./place-relation-terms.mjs";
+import { ROUTE_MODES } from "./place-relation-terms.mjs";
+import { TRAVEL_DAYS } from "./place-relation-terms.mjs";
+import { TERRAIN_MODES } from "./place-relation-terms.mjs";
+import { TERRAINS } from "./place-relation-terms.mjs";
+import { BORDER_FIELDS } from "./place-relation-terms.mjs";
+import { ROUTE_FIELDS } from "./place-relation-terms.mjs";
+import { BORDER_KEYS } from "./place-relation-terms.mjs";
+import { ROUTE_KEYS } from "./place-relation-terms.mjs";
+export { RELATION_TYPE, BEARINGS, ROUTE_MODES, TRAVEL_DAYS, TERRAIN_MODES, TERRAINS, BORDER_FIELDS, ROUTE_FIELDS, BORDER_KEYS, ROUTE_KEYS };

package/types/engine/rank-ladder.d.mts

@@ -38,3 +38,5 @@ export function checkRankLadder(note: {
     severity: string;
     message: string;
 }>;
+export { RUNG_FIELDS };
+import { RUNG_FIELDS } from "./standing-terms.mjs";

package/types/engine/region-events.d.mts

@@ -2,19 +2,13 @@
  * The curated Foundry region-event vocabulary, as plain data.
  *
  * Deliberately **plain ESM** — no TypeScript, no `@src` aliases, no Foundry —
- * for the same reason `../sohl/default-item-art.mjs` is: the map-note pack
- * compiler runs under bare `node`, outside the bundler that resolves `@src` and
- * strips types, and it must reject an authored region event that the runtime
- * would silently drop. One list here is what keeps the build-time lint and the
- * runtime bridge from drifting apart.
+ * so the Foundry runtime and any build-time consumer read one list, and the
+ * events a region trigger forwards cannot drift between them.
  *
- * It sits in this package rather than in the system's `src/` tree because the
- * map-note compiler that reads it is installed as a dependency, and a
- * relative path out of the package would resolve to garbage from
- * `node_modules`. The runtime reaches it back through the package's
- * `./engine/region-events` entry point. It is engine-side, not
- * SoHL-side, because any content module that authors a scene region — an
- * adventure module included — needs this vocabulary.
+ * The runtime reaches it through the package's `./engine/region-events` entry
+ * point. It is engine-side, not SoHL-side, because a Scene region exported
+ * from any content module — an adventure module included — names its events
+ * from this vocabulary.
  *
  * The prose explaining *why* each event is curated or excluded lives with the
  * typed re-exports in `src/entity/event/region-triggers.ts`, which is the

package/types/engine/scenes.d.mts

@@ -1,39 +1,19 @@
-/**
- * Every SoHL action name this build knows about, for the `action:` warning on a
- * region trigger.
- *
- * Deliberately a **superset**, gathered from the localization keys every
- * intrinsic action's `title:` points at and from the `shortcode:` / `executor:`
- * string literals the action definitions carry. A warning that fires on a real
- * action would be worse than one that misses a typo, so the wider net is the
- * right one: this only has to recognise the names that exist, not enumerate
- * them exactly.
- *
- * @param {string} repoRoot - The repository root.
- * @returns {Set<string>} The known action names.
- */
-export function collectKnownActionNames(repoRoot: string): Set<string>;
 /**
  * Scenes pack compiler.
  *
- * Walks the content tree and compiles every map note into one Scene, resolving
- * what one note says about another through an index built before any scene is
- * written. It also writes one Adventure per place, bundling those scenes with
- * the JournalEntries their prose compiled into, which is what makes a pinned
- * scene's id-based references resolve on import.
+ * Compiles every map note's exported Scene, and writes one Adventure per place
+ * whose scenes carry pins, bundling those scenes with the JournalEntries their
+ * prose compiled into.
  */
 export class Scenes extends BasePackCompiler {
-    constructor({ contentBase, assetsBase, dest, skipDirectories, companionDests, folderResolver, repoRoot, config, packName, bundleSourceDirs, corpus, }: {
+    constructor({ contentBase, assetsBase, dest, skipDirectories, companionDests, folderResolver, packName, corpus, }: {
         contentBase: any;
         assetsBase: any;
         dest: any;
         skipDirectories: any;
         companionDests?: {} | undefined;
         folderResolver?: (() => null) | undefined;
-        repoRoot?: string | undefined;
-        config: any;
         packName: any;
-        bundleSourceDirs?: {} | undefined;
         corpus: any;
     });
     /** @type {string} */
@@ -44,13 +24,7 @@ export class Scenes extends BasePackCompiler {
      * @type {number}
      */
     adventureCount: number;
-    mapConfig: any;
-    packName: any;
-    journalSourceDirs: any;
-    index: Map<string, object> | undefined;
-    effectsByAddress: Map<string, object> | undefined;
-    knownActions: Set<string> | undefined;
-    /** place key → `{name, img, scenes: [], journal: []}` */
+    /** place key → `{key, name, scenes: [], journal: [], pinned}` */
     places: Map<any, any> | undefined;
     /**
      * Bundle each pinned place into an Adventure, once every map of it has
@@ -58,7 +32,7 @@ export class Scenes extends BasePackCompiler {
      *
      * @returns {Promise<void>}
      */
-    finish(stats: any): Promise<void>;
+    finish(): Promise<void>;
     /** @inheritdoc */
     reportCompiled(stats: any): void;
     #private;

package/types/engine/site-build.d.mts

@@ -182,10 +182,7 @@ export function tableUniverse(pages: object[]): Map<string, object[]>;
  * 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. 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.
+ * holds the graph.
  *
  * @param {object} page - The page.
  * @param {object} options
@@ -219,25 +216,14 @@ export function pageFrontmatter(page: object, { decorate, webSrc, artSrc }: {
  * `doc` note's `subType` may be spelled the same as another note's `type`, and
  * `doc-gear.md` and `weapongear-gear.md` are distinct.
  *
- * **A page that carries a file beside itself is a leaf bundle**, `<slug>/index.md`,
- * because that is the one shape under which Hugo hands a page its own
- * resources — the map from a place, inlined by the theme through
- * `.Resources.Get`. The directory is the page, not a section: it holds no
- * `_index.md`, and the page's stated `url` keeps its address exactly where the
- * flat file's was.
- *
  * @param {{slug: string}} page - The page.
- * @param {object} [opts]
- * @param {boolean} [opts.bundle=false] - Whether the page carries a resource.
  * @returns {string} The file, relative to the mount.
  */
 export function pageDestination(page: {
     slug: string;
-}, { bundle }?: {
-    bundle?: boolean | undefined;
 }): string;
 /** Transform one content page without writing the site mount. */
-export function renderSitePage(page: any, { index, foreign, universe, pass, decorate, linkable, sqlTables, config, artIndex, figuresByAddress, }: {
+export function renderSitePage(page: any, { index, foreign, universe, pass, decorate, linkable, sqlTables, config, artIndex, figuresByAddress, events, drawings, }: {
     index: any;
     foreign: any;
     universe: any;
@@ -248,6 +234,8 @@ export function renderSitePage(page: any, { index, foreign, universe, pass, deco
     config: any;
     artIndex: any;
     figuresByAddress?: Map<any, any> | undefined;
+    events: any;
+    drawings?: Map<any, any> | undefined;
 }): {
     page: any;
     body: string;
@@ -311,25 +299,23 @@ export function renderSitePage(page: any, { index, foreign, universe, pass, deco
  * point the resolver answers, and inverted once between them. Nothing is
  * resolved twice.
  *
- * **A map is written with its page.** The drawing from a place is made before
+ * **A map is set inline in its page.** The drawing from a place is made before
  * this render — see {@link module:engine/site-maps} — and handed in keyed by
- * page URL; the page that owns one is written as a leaf bundle, the file is
- * copied beside it, and the front matter names it as `map`. Every other page
- * is written flat, and carries no such key.
+ * the file name the page's **From here** section names.
  *
  * @param {object[]} pages - Every page.
  * @param {object} options - Everything the render needs. `homepages` is the
  *   homepage as the index knows it — `{ fm, body, url, title }` — which takes
  *   no part in the render and every part in the graph: a content page links
  *   it by wikilink, and its own markdown links name content pages. `maps` is
- *   each drawing by the URL of the page that carries it.
+ *   each drawing by the file name a **From here** section names.
  * @returns {{written: number, byKind: Record<string, number>, tableErrors: object[],
  *   wikiErrors: object[], imageErrors: object[], embedErrors: object[],
  *   related: Map<string, import("./related-pages.mjs").Related>,
  *   maps: number}} `related`
  *   is keyed by page URL, and holds the homepage's block beside every content
  *   page's, so the caller can write it on the page this render does not.
- *   `maps` counts the pages written with one.
+ *   `maps` counts the pages carrying a map.
  */
 export function renderPages(pages: object[], options: object): {
     written: number;