@heroiclands/package-build 23.0.0 → 23.1.0

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;

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

@@ -2,8 +2,7 @@
  * A drawing as the page writer receives it.
  *
  * @typedef {object} SiteMap
- * @property {string} name - The file's name in the page's bundle, and the
- *   value of the page's `map` key: `from-<shortcode>.svg`.
+ * @property {string} name - The file's name: `from-<shortcode>.svg`.
  * @property {string} file - Where the drawing is, absolute.
  */
 /**
@@ -24,7 +23,7 @@
  */
 export function inlineSvg(svg: string): string;
 /**
- * Draw the map from every related place of this package.
+ * Draw the map from every place of this package that is given one.
  *
  * @param {object} opts
  * @param {Array<Record<string, any>>} opts.records - The package's index
@@ -36,8 +35,8 @@ export function inlineSvg(svg: string): string;
  *   ending in a slash: what every name in a drawing links through.
  * @returns {{maps: Map<string, SiteMap>, findings: Array<{file: string,
  *   line?: number, column?: number, severity: "error"|"warning",
- *   message: string}>}} The drawings, keyed by the URL of the page each
- *   belongs to, and warnings for relations that name no place.
+ *   message: string}>}} The drawings, keyed by the file name a **From here**
+ *   section names, and warnings for relations that name no place.
  */
 export function drawSiteMaps({ records, foreignIndex, config, base }: {
     records: Array<Record<string, any>>;
@@ -54,6 +53,16 @@ export function drawSiteMaps({ records, foreignIndex, config, base }: {
         message: string;
     }>;
 };
+/**
+ * The figure the website sets a drawing in: the SVG inline, so its place names
+ * stay links, with no blank line inside it — a blank line would end the HTML
+ * block and hand the rest of the drawing to the Markdown renderer.
+ *
+ * @param {string} svg - The drawing, as {@link inlineSvg} wrote it.
+ * @param {string} alt - What the drawing shows, for a screen reader.
+ * @returns {string} One HTML block.
+ */
+export function inlineDrawingFigure(svg: string, alt: string): string;
 /**
  * Where the site build draws, below the package root.
  *
@@ -65,8 +74,7 @@ export const SITE_MAP_DIR: string;
  */
 export type SiteMap = {
     /**
-     * - The file's name in the page's bundle, and the
-     * value of the page's `map` key: `from-<shortcode>.svg`.
+     * - The file's name: `from-<shortcode>.svg`.
      */
     name: string;
     /**

package/types/engine/sql-tables.d.mts

@@ -164,6 +164,77 @@ export function prepareSqlTables(db: object, sources: Array<{
 }): Promise<Map<string, object[]>>;
 /** Evaluate scalar SQL calls before synchronous Markdown renderers run. */
 export function prepareInlineSqlExpressions(db: any, sources: any): Promise<Map<any, any>>;
+/**
+ * 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 function generatedSectionsFor(db: object | undefined, records: object[], contentBase: string, { only, foreignIndex, config, derived: given }?: {
+    only?: string | undefined;
+    foreignIndex?: Map<string, object> | undefined;
+    config?: object | undefined;
+    derived?: Map<string, Map<string, string>> | undefined;
+}): Promise<{
+    sections: Map<string, string>;
+    views: Set<string>;
+    derived: Map<string, Map<string, string>>;
+}>;
+/**
+ * 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: {
+    sections: Map<string, string>;
+    views: Set<string>;
+}, sources: Array<{
+    source: string;
+    markdown: string;
+    frontmatter?: object;
+}>): void;
+/**
+ * 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: Map<string, object[]>, generated: {
+    sections: Map<string, string>;
+}): void;
 /**
  * Answer every `sql` directive in a content tree.
  *
@@ -189,15 +260,19 @@ export function prepareInlineSqlExpressions(db: any, sources: any): Promise<Map<
  *   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 function prepareTreeSqlTables(contentBase: string, { config, skipDirectories, records, audience }?: {
+export function prepareTreeSqlTables(contentBase: string, { config, skipDirectories, records, audience, foreignIndex }?: {
     config?: object | undefined;
     skipDirectories?: readonly string[] | undefined;
     records?: object[] | undefined;
     audience?: "all" | "public" | undefined;
+    foreignIndex?: Map<string, object> | undefined;
 }): Promise<Map<string, object[]> | undefined>;
 /**
  * Aliases the renderer reads rather than printing.