@heroiclands/package-build 23.0.0 → 23.1.0

package/docs/api.md

@@ -104,7 +104,8 @@ Deterministic document ids, derived by hashing rather than stored, so compile pa
 | ---------------------- | ----------------------------------------------- | -------------------------------------------------------------- | ------------------------------------------------------------------------------------------ |
 | `makeId`               | `makeId(namespace, value)`                      | `string` — a 16-character hexadecimal Foundry id               | deriving a stable id from a namespace and a value, e.g. a heading id when none is supplied |
 | `MAP_TYPES`            | `const MAP_TYPES`                               | —                                                              | enumerating the content types that compile into a Foundry `Scene`                          |
-| `MAP_SUBTYPES`         | `const MAP_SUBTYPES`                            | —                                                              | reading the map subTypes, which differ only in derived canvas defaults                     |
+| `isMapType`            | `isMapType(type)`                               | `boolean`                                                      | asking whether a content note's type compiles into a Scene                                 |
+| `MAP_SUBTYPES`         | `const MAP_SUBTYPES`                            | —                                                              | reading the map subTypes, each of which carries an exported Scene                          |
 | `JOURNAL_TYPES`        | `const JOURNAL_TYPES`                           | —                                                              | enumerating content types whose whole document _is_ a JournalEntry                         |
 | `NO_PACK`              | `const NO_PACK`                                 | —                                                              | spelling the `pack:` value (`none`) that routes a note's document into no compendium       |
 | `PACK_BY_TYPE`         | `const PACK_BY_TYPE`                            | —                                                              | looking up the conventional pack name and document type for a content type                 |
@@ -352,29 +353,29 @@ The note types the engine itself declares — vocabulary that is a fact about th
 
 An addressed content note accepts exactly these top-level keys, in this order: `shortcode`, `name`, `type`, `subType`, `description`, `tags`, `data`, `dnd5e`, `hm3`, `sohl`. A key outside this list is an error at its own line. The system blocks are one per system the address vocabulary recognizes, sorted by name after the fixed keys, so a further system is a change to `SYSTEM_IDS` alone. No dnd5e-specific document types are declared. Within that shape, the closed vocabularies are the `data:` container and each type's `subType`.
 
-| Export                    | Signature                                    | Returns                                  | Use it when                                                                                  |
-| ------------------------- | -------------------------------------------- | ---------------------------------------- | -------------------------------------------------------------------------------------------- |
-| `DRAFT_TAG`               | `const DRAFT_TAG`                            | —                                        | naming the declared tag that marks a note as unfinished                                      |
-| `GM_TAG`                  | `const GM_TAG`                               | —                                        | naming the declared tag that marks a GM-only note                                            |
-| `BEING_ARCHETYPES`        | `const BEING_ARCHETYPES`                     | `Readonly<Record<string, string>>`       | looking up the case-sensitive being archetypes and their meanings                            |
-| `NOTE_VOCABULARY`         | `const NOTE_VOCABULARY`                      | —                                        | looking up, per content type, its `data:` field list and its closed `subType` values         |
-| `NOTE_TOP_LEVEL_FIELDS`   | `const NOTE_TOP_LEVEL_FIELDS`                | `readonly TopLevelFieldSpec[]`           | reading the top-level keys a note accepts, in formatted order, with what each one means      |
-| `NOTE_TOP_LEVEL_KEYS`     | `const NOTE_TOP_LEVEL_KEYS`                  | `readonly string[]`                      | reading just the key names, in the order the formatter writes them                           |
-| `NOTE_TOP_LEVEL_KEY_SET`  | `const NOTE_TOP_LEVEL_KEY_SET`               | `ReadonlySet<string>`                    | testing whether a top-level key is one the note format declares                              |
-| `SHARED_DATA_FIELDS`      | `const SHARED_DATA_FIELDS`                   | `readonly DataFieldSpec[]`               | reading the `data:` keys every type accepts, whatever it is — the art slots legal everywhere |
-| `DECLARED_TAGS`           | `const DECLARED_TAGS`                        | —                                        | looking up the tags a note type may declare, grouped                                         |
-| `declaredTags`            | `declaredTags(type, groups)`                 | `readonly string[]`                      | reading the declared tags a note of a type may carry, flattened                              |
-| `applicableTagGroups`     | `applicableTagGroups(type, groups)`          | `object[]`                               | reading the declared tag groups that apply to a note type                                    |
-| `exclusiveTagGroups`      | `exclusiveTagGroups(type, groups)`           | `Array<{slot, tags}>`                    | reading single-valued tag slots declared for a note type                                     |
-| `hasTag`                  | `hasTag(fm, tag)`                            | `boolean`                                | checking whether a note carries a given tag, whatever scalar-or-list form it was authored in |
-| `isDraftNote`             | `isDraftNote(fm)`                            | `boolean`                                | checking whether a note is tagged as an unfinished draft                                     |
-| `isGmNote`                | `isGmNote(fm)`                               | `boolean`                                | checking whether a note is restricted to GM-facing output                                    |
-| `subTypeCharsetMessage`   | `subTypeCharsetMessage(value)`               | `string`                                 | building the message for a `subType` outside the address charset                             |
-| `typeCharsetMessage`      | `typeCharsetMessage(type)`                   | `string`                                 | building the message for a `type` outside the address charset                                |
-| `assertVocabularyCharset` | `assertVocabularyCharset(vocabulary, where)` | throws                                   | refusing a vocabulary declaration whose type or subType breaks the address charset           |
-| `isLegacyDataField`       | `isLegacyDataField(type, key)`               | `boolean`                                | testing accepted but ignored transitional affiliation `data.domains` input                   |
-| `dataFields`              | `dataFields(type, vocabulary)`               | `readonly DataFieldSpec[] \| undefined`  | looking up the `data:` keys a note type may carry                                            |
-| `subTypes`                | `subTypes(type, vocabulary)`                 | `readonly string[] \| null \| undefined` | looking up the closed `subType` values a note type declares                                  |
+| Export                    | Signature                                    | Returns                                  | Use it when                                                                                       |
+| ------------------------- | -------------------------------------------- | ---------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| `DRAFT_TAG`               | `const DRAFT_TAG`                            | —                                        | naming the declared tag that marks a note as unfinished                                           |
+| `GM_TAG`                  | `const GM_TAG`                               | —                                        | naming the declared tag that marks a GM-only note                                                 |
+| `BEING_ARCHETYPES`        | `const BEING_ARCHETYPES`                     | `Readonly<Record<string, string>>`       | looking up the case-sensitive being archetypes and their meanings                                 |
+| `NOTE_VOCABULARY`         | `const NOTE_VOCABULARY`                      | —                                        | looking up, per content type, its `data:` field list and its closed `subType` values              |
+| `NOTE_TOP_LEVEL_FIELDS`   | `const NOTE_TOP_LEVEL_FIELDS`                | `readonly TopLevelFieldSpec[]`           | reading the top-level keys a note accepts, in formatted order, with what each one means           |
+| `NOTE_TOP_LEVEL_KEYS`     | `const NOTE_TOP_LEVEL_KEYS`                  | `readonly string[]`                      | reading just the key names, in the order the formatter writes them                                |
+| `NOTE_TOP_LEVEL_KEY_SET`  | `const NOTE_TOP_LEVEL_KEY_SET`               | `ReadonlySet<string>`                    | testing whether a top-level key is one the note format declares                                   |
+| `SHARED_DATA_FIELDS`      | `const SHARED_DATA_FIELDS`                   | `readonly DataFieldSpec[]`               | reading the `data:` keys every type accepts, whatever it is — the art slots legal everywhere      |
+| `EVENTS_FIELD`            | `const EVENTS_FIELD`                         | `DataFieldSpec`                          | reading the one `events` declaration that `lore`, `place` and `affiliation` share, with its check |
+| `DECLARED_TAGS`           | `const DECLARED_TAGS`                        | —                                        | looking up the tags a note type may declare, grouped                                              |
+| `declaredTags`            | `declaredTags(type, groups)`                 | `readonly string[]`                      | reading the declared tags a note of a type may carry, flattened                                   |
+| `applicableTagGroups`     | `applicableTagGroups(type, groups)`          | `object[]`                               | reading the declared tag groups that apply to a note type                                         |
+| `exclusiveTagGroups`      | `exclusiveTagGroups(type, groups)`           | `Array<{slot, tags}>`                    | reading single-valued tag slots declared for a note type                                          |
+| `hasTag`                  | `hasTag(fm, tag)`                            | `boolean`                                | checking whether a note carries a given tag, whatever scalar-or-list form it was authored in      |
+| `isDraftNote`             | `isDraftNote(fm)`                            | `boolean`                                | checking whether a note is tagged as an unfinished draft                                          |
+| `isGmNote`                | `isGmNote(fm)`                               | `boolean`                                | checking whether a note is restricted to GM-facing output                                         |
+| `subTypeCharsetMessage`   | `subTypeCharsetMessage(value)`               | `string`                                 | building the message for a `subType` outside the address charset                                  |
+| `typeCharsetMessage`      | `typeCharsetMessage(type)`                   | `string`                                 | building the message for a `type` outside the address charset                                     |
+| `assertVocabularyCharset` | `assertVocabularyCharset(vocabulary, where)` | throws                                   | refusing a vocabulary declaration whose type or subType breaks the address charset                |
+| `dataFields`              | `dataFields(type, vocabulary)`               | `readonly DataFieldSpec[] \| undefined`  | looking up the `data:` keys a note type may carry                                                 |
+| `subTypes`                | `subTypes(type, vocabulary)`                 | `readonly string[] \| null \| undefined` | looking up the closed `subType` values a note type declares                                       |
 
 ### `engine.infobox`
 
@@ -392,7 +393,8 @@ The declared infobox: what a note's summary panel holds, decided once and render
 | `NOTHING_BEYOND_PROFILE`  | `const NOTHING_BEYOND_PROFILE`         | —                           | naming what a system holding nothing the note box has not shown says                   |
 | `NOTE_BOX_ID`             | `const NOTE_BOX_ID`                    | —                           | naming the note infobox, which is not a system id                                      |
 | `NOTE_BOX_TITLE`          | `const NOTE_BOX_TITLE`                 | —                           | naming the note infobox's heading                                                      |
-| `NOTE_SECTION_ID`         | `const NOTE_SECTION_ID`                | —                           | naming the note infobox's single section                                               |
+| `NOTE_SECTION_ID`         | `const NOTE_SECTION_ID`                | —                           | naming the note infobox's profile section                                              |
+| `MEMBERSHIPS_SECTION`     | `const MEMBERSHIPS_SECTION`            | —                           | naming the note infobox's `list` section of a being's memberships, one line each       |
 | `NOTE_FIELD_PRESENTATION` | `const NOTE_FIELD_PRESENTATION`        | —                           | looking up a `data:` key's label, the group it composes into, or why it carries no row |
 | `assertInfoboxSet`        | `assertInfoboxSet(boxes, fm, options)` | `readonly object[]`, throws | refusing a page that carries anything but the boxes its type maps to                   |
 | `buildInfoboxes`          | `buildInfoboxes(fm, options)`          | `object[]`                  | building every box a note carries, against a given set of maps and declarations        |
@@ -482,36 +484,35 @@ Every typed note must have a nonempty body. Empty and whitespace-only bodies are
 
 What a place is next to (`data.borders`) and reachable from (`data.routes`): the closed sets both draw from, stated once for the lint, the specification and a consumer drawing a map, and the checks that hold a note to them and to the note at the other end.
 
-| Export            | Signature                       | Returns             | Use it when                                                                                                          |
-| ----------------- | ------------------------------- | ------------------- | -------------------------------------------------------------------------------------------------------------------- |
-| `RELATION_TYPE`   | `const RELATION_TYPE`           | `string`            | the type a `to` names — the default its `<type>` segment takes and the whole of its accepted set                     |
-| `BEARINGS`        | `const BEARINGS`                | `readonly string[]` | the eight compass bearings, clockwise from `N`                                                                       |
-| `ROUTE_MODES`     | `const ROUTE_MODES`             | `readonly string[]` | the modes a route is travelled by — `land`, `boat`, `ship`                                                           |
-| `TRAVEL_DAYS`     | `const TRAVEL_DAYS`             | `readonly number[]` | the days markers a route may state, each meaning "about this, under normal conditions"                               |
-| `TERRAIN_MODES`   | `const TERRAIN_MODES`           | —                   | the terrain registry, each terrain naming the modes that cross it                                                    |
-| `TERRAINS`        | `const TERRAINS`                | `readonly string[]` | the terrain names, in registry order                                                                                 |
-| `BORDER_KEYS`     | `const BORDER_KEYS`             | `readonly string[]` | the keys a `borders` entry carries                                                                                   |
-| `ROUTE_KEYS`      | `const ROUTE_KEYS`              | `readonly string[]` | the keys a `routes` entry carries                                                                                    |
-| `oppositeBearing` | `oppositeBearing(bearing)`      | `string\|undefined` | the bearing the other end of a relation states, or `undefined` for a value that is not a bearing                     |
-| `checkBorders`    | `checkBorders(note, { index })` | `object[]`          | linting a place's `borders` — targets, values, once per pair, no parent or child, and reciprocity with the other end |
-| `checkRoutes`     | `checkRoutes(note, { index })`  | `object[]`          | linting a place's `routes` — as `checkBorders`, plus `mode`, `days` and `terrain`, once per pair per mode            |
+| Export            | Signature                       | Returns             | Use it when                                                                                                                                                         |
+| ----------------- | ------------------------------- | ------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `RELATION_TYPE`   | `const RELATION_TYPE`           | `string`            | the type a `to` names — the default its `<type>` segment takes and the whole of its accepted set                                                                    |
+| `BEARINGS`        | `const BEARINGS`                | `readonly string[]` | the eight compass bearings, clockwise from `N`                                                                                                                      |
+| `ROUTE_MODES`     | `const ROUTE_MODES`             | `readonly string[]` | the modes a route is travelled by — `land`, `boat`, `ship`                                                                                                          |
+| `TRAVEL_DAYS`     | `const TRAVEL_DAYS`             | `readonly number[]` | the days markers a route may state, each meaning "about this, under normal conditions"                                                                              |
+| `TERRAIN_MODES`   | `const TERRAIN_MODES`           | —                   | the terrain registry, each terrain naming the modes that cross it                                                                                                   |
+| `TERRAINS`        | `const TERRAINS`                | `readonly string[]` | the terrain names, in registry order                                                                                                                                |
+| `BORDER_FIELDS`   | `const BORDER_FIELDS`           | `readonly object[]` | the keys a `borders` entry carries, as inner-key declarations — name, kind, shape and whether it is required                                                        |
+| `ROUTE_FIELDS`    | `const ROUTE_FIELDS`            | `readonly object[]` | the keys a `routes` entry carries, as inner-key declarations                                                                                                        |
+| `BORDER_KEYS`     | `const BORDER_KEYS`             | `readonly string[]` | the keys a `borders` entry carries                                                                                                                                  |
+| `ROUTE_KEYS`      | `const ROUTE_KEYS`              | `readonly string[]` | the keys a `routes` entry carries                                                                                                                                   |
+| `oppositeBearing` | `oppositeBearing(bearing)`      | `string\|undefined` | the bearing the other end of a relation states, or `undefined` for a value that is not a bearing                                                                    |
+| `checkBorders`    | `checkBorders(note, { index })` | `object[]`          | linting what a place's `borders` mean — targets, bearings, once per pair, no parent or child, and reciprocity; an entry's keys and shape are the frontmatter lint's |
+| `checkRoutes`     | `checkRoutes(note, { index })`  | `object[]`          | linting what a place's `routes` mean — as `checkBorders`, plus `mode`, `days` and `terrain`, once per pair per mode                                                 |
 
 ### `engine.holdings`
 
-What lies within a place and which affiliation explicitly governs it — read off `data.parents` and resolved explicit `data.government` across this package and every fetched index, inverted into the `contains`, `governed_by` and `governed_places` lists the site build writes — and the population-based government advisory `package-build lint` runs on a place.
+What lies within a place and which affiliation explicitly governs it — read off `data.parents` and resolved explicit `data.government` across this package and every fetched index, inverted into the lists a note's generated **Within**, **Governed by** and **Governed places** sections show — and the population-based government advisory `package-build lint` runs on a place.
 
-| Export                 | Signature                                           | Returns                 | Use it when                                                                                                                                |
-| ---------------------- | --------------------------------------------------- | ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------ |
-| `HOLDINGS_KEYS`        | `const HOLDINGS_KEYS`                               | `readonly string[]`     | derived `contains`, `governed_by`, `governed_places` and retired `held_by`/`holdings` keys removed from authored page metadata             |
-| `HELD_SUBTYPES`        | `const HELD_SUBTYPES`                               | `readonly string[]`     | deprecated historical tenure subtypes; government checks apply to every place subtype                                                      |
-| `holdingsNode`         | `holdingsNode(fm, { title, url, package, system })` | `HoldingsNode\|null`    | reading a local note as a node of the derivation, or `null` for one that is neither a place nor an affiliation                             |
-| `foreignHoldingsNodes` | `foreignHoldingsNodes(foreignIndex)`                | `HoldingsNode[]`        | reading a fetched index's places and affiliations as nodes                                                                                 |
-| `holdingsPages`        | `holdingsPages(nodes, { governmentNodes })`         | `Map<string, Holdings>` | inverting `parents` and resolved explicit `government` into each page's sorted lists, keyed by URL, for every page with at least one entry |
-| `shortcodesOf`         | `shortcodesOf(value)`                               | `string[]`              | the shortcodes a `parents` value names — bare or qualified Addresses — empties dropped and repeats collapsed                               |
-| `checkGovernment`      | `checkGovernment(note)`                             | `object[]`              | warning at `data.population` for positive population with no own `data.government` key; explicit null means anarchy                        |
-| `checkHeld`            | `checkHeld(note, { index })`                        | `object[]`              | deprecated compatibility wrapper for `checkGovernment`; holdings do not determine government                                               |
+| Export                 | Signature                                                      | Returns                 | Use it when                                                                                                                                        |
+| ---------------------- | -------------------------------------------------------------- | ----------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `holdingsNode`         | `holdingsNode(fm, { title, url, package, system, canonical })` | `HoldingsNode\|null`    | reading a local note as a node of the derivation, or `null` for one that is neither a place nor an affiliation                                     |
+| `foreignHoldingsNodes` | `foreignHoldingsNodes(foreignIndex)`                           | `HoldingsNode[]`        | reading a fetched index's places and affiliations as nodes                                                                                         |
+| `holdingsPages`        | `holdingsPages(nodes, { governmentNodes })`                    | `Map<string, Holdings>` | inverting `parents` and resolved explicit `government` into each node's sorted lists, keyed by its `url`, for every node with a `url` and an entry |
+| `shortcodesOf`         | `shortcodesOf(value)`                                          | `string[]`              | the shortcodes a `parents` value names — bare or qualified Addresses — empties dropped and repeats collapsed                                       |
+| `checkGovernment`      | `checkGovernment(note)`                                        | `object[]`              | warning at `data.population` for positive population with no own `data.government` key; explicit null means anarchy                                |
 
-Government-only supplemental records passed in `holdingsPages` options include public local stubs in the reverse lists without adding them to the geographical graph. Published nodes retain precedence; stubs without URLs render as plain text.
+An entry carries the listed note's `title`, its `address` in the `note` system, its `type` and `subType`, and its `url` where the note has one. A node with no `url` — a stub — is listed by others and carries no list of its own. Records passed as `governmentNodes` take part in government alone, never in geography.
 
 ### `engine.populations`
 
@@ -588,12 +589,12 @@ The drawings of `package-build map` as DOT text, sharing one style table: shape,
 
 ### `engine.mapGraphviz`
 
-The npm-installed Graphviz runtime draws SVG maps and supplies the plain positions used by Foundry itinerary pins. PNG backgrounds are rasterized from the same SVG layout. The `.dot` source stays beside each rendering.
+The npm-installed Graphviz runtime draws SVG maps. The `.dot` source stays beside each rendering.
 
-| Export             | Signature                                                   | Returns             | Use it when                                            |
-| ------------------ | ----------------------------------------------------------- | ------------------- | ------------------------------------------------------ |
-| `GRAPHVIZ_ENGINES` | `const GRAPHVIZ_ENGINES`                                    | `readonly string[]` | choosing `dot`, `twopi`, or `neato`                    |
-| `renderDot`        | `renderDot(dotPath, outPath, { engine, format, nop, dpi })` | `{warnings}`        | rendering a DOT source to SVG, plain positions, or PNG |
+| Export             | Signature                                      | Returns             | Use it when                         |
+| ------------------ | ---------------------------------------------- | ------------------- | ----------------------------------- |
+| `GRAPHVIZ_ENGINES` | `const GRAPHVIZ_ENGINES`                       | `readonly string[]` | choosing `dot`, `twopi`, or `neato` |
+| `renderDot`        | `renderDot(dotPath, outPath, { engine, nop })` | `{warnings}`        | rendering a DOT source to SVG       |
 
 ### `engine.mapBuild`
 
@@ -608,13 +609,14 @@ The npm-installed Graphviz runtime draws SVG maps and supplies the plain positio
 
 ### `engine.siteMaps`
 
-The map from each place, drawn for the site: `package-build site` draws the map from every place of this package that states, or is named in, a border or a route — with the site's base, so every name links through it — and the page writer lays each drawing beside its page as `from-<shortcode>.svg` and names it in the front matter as `map`. `site.maps: false` draws none.
+The map from each place, drawn for the site: `package-build site` draws the map from every place of this package given a **From here** section — with the site's base, so every name links through it — and sets each drawing inline in that section, where its place names stay links. `site.maps: false` gives no place the section, and nothing is drawn.
 
-| Export         | Signature                                               | Returns            | Use it when                                                                                                     |
-| -------------- | ------------------------------------------------------- | ------------------ | --------------------------------------------------------------------------------------------------------------- |
-| `SITE_MAP_DIR` | `const SITE_MAP_DIR`                                    | `string`           | where the site build draws below a package's root, `build/map/site`                                             |
-| `inlineSvg`    | `inlineSvg(svg)`                                        | `string`           | rewriting a GraphViz SVG for inlining — no prologue, no comment, no `xlink:`, the root sized by `viewBox` alone |
-| `drawSiteMaps` | `drawSiteMaps({ records, foreignIndex, config, base })` | `{maps, findings}` | drawing the map from every related place of this package, keyed by the URL of the page that carries it          |
+| Export                | Signature                                               | Returns            | Use it when                                                                                                     |
+| --------------------- | ------------------------------------------------------- | ------------------ | --------------------------------------------------------------------------------------------------------------- |
+| `SITE_MAP_DIR`        | `const SITE_MAP_DIR`                                    | `string`           | where the site build draws below a package's root, `build/map/site`                                             |
+| `inlineSvg`           | `inlineSvg(svg)`                                        | `string`           | rewriting a GraphViz SVG for inlining — no prologue, no comment, no `xlink:`, the root sized by `viewBox` alone |
+| `drawSiteMaps`        | `drawSiteMaps({ records, foreignIndex, config, base })` | `{maps, findings}` | drawing the map from every place given a **From here** section, keyed by the file name the section names        |
+| `inlineDrawingFigure` | `inlineDrawingFigure(svg, alt)`                         | `string`           | the one HTML block the website sets an inline drawing in, with no blank line to end it early                    |
 
 ### `engine.systems`
 
@@ -658,7 +660,7 @@ The neutral day spelling is `<year>.<day>[:HHMMSS]`. The pure conversion functio
 
 ### `engine.noteDates`
 
-A date on a note is one authored scalar. `<year>[.<day>[:HHMMSS]]` names a calendar-neutral year, day, or second; `datefrom vrcal 23 Taranis 326 VR` names a calendar, a named month, and an era. Year and day values span their written interval; a clock time identifies a second. Either form may begin with `~` for uncertainty beyond that interval. The `approximate` field records that explicit marker, while `precision` and `seconds` describe the interval or time. A resolved date carries a canonical year, span, and sort key; a neutral year has no `canonicalDay`, while day-precision dates have one. Print `prose ?? text`, order on `sort`, and do arithmetic on `canonicalYear`. The literal `unknown` has no sort key or canonical year. Year `0` is accepted only where a caller passes `allowZeroYear` — a `lore` event's `when` — and means "this day, every year": the value carries no `canonicalYear` and no `sort`. `resolvedDateFields` supplies identical derived records to JSONL and generated page frontmatter, including a `lore` note's `data.events`, each entry's `recurs` and computed `next`.
+A date on a note is one authored scalar. `<year>[.<day>[:HHMMSS]]` names a calendar-neutral year, day, or second; `datefrom vrcal 23 Taranis 326 VR` names a calendar, a named month, and an era. Year and day values span their written interval; a clock time identifies a second. Either form may begin with `~` for uncertainty beyond that interval. The `approximate` field records that explicit marker, while `precision` and `seconds` describe the interval or time. A resolved date carries a canonical year, span, and sort key; a neutral year has no `canonicalDay`, while day-precision dates have one. Print `prose ?? text`, order on `sort`, and do arithmetic on `canonicalYear`. The literal `unknown` has no sort key or canonical year. Year `0` is accepted only where a caller passes `allowZeroYear` — an event's `when` — and means "this day, every year": the value carries no `canonicalYear` and no `sort`. `resolvedDateFields` supplies the derived records the JSONL carries, including each `data.events` entry's dates, `recurs` and computed `next`; generated page front matter carries the same records for every date except an event's.
 
 | Export                  | Signature                                                     | Returns                                            | Use it when                                                    |
 | ----------------------- | ------------------------------------------------------------- | -------------------------------------------------- | -------------------------------------------------------------- |
@@ -725,22 +727,23 @@ The corpus registry anchors each calendar's year 1, day 1 to its canonical `data
 
 A calendar is a `lore` note with `subType: calendar`, declaring the months it keeps, the weekdays it names, the seasons it marks and the eras it counts years in. How long the year is, how the day divides and how the moon moves are facts about the **world**, written on its `place` note and its moon's, and no calendar may restate them — which is why the months summing to the world's year is the only arithmetic a calendar note is held to. One definition is emitted per calendar, in array shape: Foundry core prunes the keys outside its schema, and Calendaria converts the arrays to its own keyed collections.
 
-| Export                      | Signature                                             | Returns                                    | Use it when                                                                 |
-| --------------------------- | ----------------------------------------------------- | ------------------------------------------ | --------------------------------------------------------------------------- |
-| `CALENDAR_SUBTYPE`          | `const CALENDAR_SUBTYPE`                              | —                                          | naming the `lore` subType whose notes are calendars                         |
-| `INVARIANT_SUBTYPES`        | `const INVARIANT_SUBTYPES`                            | —                                          | naming the `place` subTypes a world fact may be written on                  |
-| `CALENDAR_FIELDS`           | `const CALENDAR_FIELDS`                               | —                                          | reading the closed list of what a calendar note may declare                 |
-| `CALENDAR_DATE_FORMAT_KEYS` | `const CALENDAR_DATE_FORMAT_KEYS`                     | —                                          | reading the supported Calendaria display slots                              |
-| `CALENDAR_FORMAT_TOKENS`    | `const CALENDAR_FORMAT_TOKENS`                        | —                                          | checking bare date tokens in a format string                                |
-| `INVARIANT_FIELDS`          | `const INVARIANT_FIELDS`                              | —                                          | reading the closed list of what a body may declare about itself             |
-| `checkCalendarNote`         | `checkCalendarNote(note, opts)`                       | `object[]` — findings                      | holding a `lore` note to the family and to the year the world keeps         |
-| `checkCalendarDateFormats`  | `checkCalendarDateFormats(note)`                      | `object[]` — findings                      | checking named patterns and the readable default                            |
-| `checkWorldFacts`           | `checkWorldFacts(note, opts)`                         | `object[]` — findings                      | holding a `place` note's world facts to one body, one year and one moon     |
-| `worldInvariants`           | `worldInvariants(index)`                              | `{year, present, moon, body, moonName, …}` | reading the year, the present and the moon a package's own notes state      |
-| `quarterDays`               | `quarterDays(daysPerYear)`                            | `number[]` — four days of the year         | asking which days the year turns on                                         |
-| `compileCalendar`           | `compileCalendar({note, invariants, contentPackage})` | `object` — the definition                  | building the one object both a core consumer and Calendaria read            |
-| `compileCalendars`          | `compileCalendars(index, opts)`                       | `{calendars, invariants}`                  | building every calendar a package declares, or none where it states no year |
-| `calendariaEnvelope`        | `calendariaEnvelope(definition, opts)`                | `object` — the import envelope             | wrapping a definition for a hand import through Calendaria's settings       |
+| Export                      | Signature                                             | Returns                                    | Use it when                                                                       |
+| --------------------------- | ----------------------------------------------------- | ------------------------------------------ | --------------------------------------------------------------------------------- |
+| `CALENDAR_SUBTYPE`          | `const CALENDAR_SUBTYPE`                              | —                                          | naming the `lore` subType whose notes are calendars                               |
+| `INVARIANT_SUBTYPES`        | `const INVARIANT_SUBTYPES`                            | —                                          | naming the `place` subTypes a world fact may be written on                        |
+| `CALENDAR_FIELDS`           | `const CALENDAR_FIELDS`                               | —                                          | reading the closed list of what a calendar note may declare                       |
+| `CALENDAR_ENTRY_FIELDS`     | `const CALENDAR_ENTRY_FIELDS`                         | —                                          | reading the keys one entry of each calendar list takes, as inner-key declarations |
+| `CALENDAR_DATE_FORMAT_KEYS` | `const CALENDAR_DATE_FORMAT_KEYS`                     | —                                          | reading the supported Calendaria display slots                                    |
+| `CALENDAR_FORMAT_TOKENS`    | `const CALENDAR_FORMAT_TOKENS`                        | —                                          | checking bare date tokens in a format string                                      |
+| `INVARIANT_FIELDS`          | `const INVARIANT_FIELDS`                              | —                                          | reading the closed list of what a body may declare about itself                   |
+| `checkCalendarNote`         | `checkCalendarNote(note, opts)`                       | `object[]` — findings                      | holding a `lore` note to the family and to the year the world keeps               |
+| `checkCalendarDateFormats`  | `checkCalendarDateFormats(note)`                      | `object[]` — findings                      | checking named patterns and the readable default                                  |
+| `checkWorldFacts`           | `checkWorldFacts(note, opts)`                         | `object[]` — findings                      | holding a `place` note's world facts to one body, one year and one moon           |
+| `worldInvariants`           | `worldInvariants(index)`                              | `{year, present, moon, body, moonName, …}` | reading the year, the present and the moon a package's own notes state            |
+| `quarterDays`               | `quarterDays(daysPerYear)`                            | `number[]` — four days of the year         | asking which days the year turns on                                               |
+| `compileCalendar`           | `compileCalendar({note, invariants, contentPackage})` | `object` — the definition                  | building the one object both a core consumer and Calendaria read                  |
+| `compileCalendars`          | `compileCalendars(index, opts)`                       | `{calendars, invariants}`                  | building every calendar a package declares, or none where it states no year       |
+| `calendariaEnvelope`        | `calendariaEnvelope(definition, opts)`                | `object` — the import envelope             | wrapping a definition for a hand import through Calendaria's settings             |
 
 ### `engine.calendarArtifacts`
 
@@ -878,7 +881,7 @@ Emitting this package's content index. Every content build already walks the who
 
 | Export                | Signature                        | Returns                                                        | Use it when                                                                                                                                                                      |
 | --------------------- | -------------------------------- | -------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `collectAnchors`      | `collectAnchors(body, bodyLine)` | `Array<{slug: string, line: number}>`                          | reading a note body's anchors, shared with the link checker and every build that emits a link                                                                                    |
+| `collectAnchors`      | `collectAnchors(body, bodyLine)` | `Array<{slug: string, line: number, kind: string}>`            | reading a note body's anchors, each with its kind, shared with the link checker and every build that emits a link                                                                |
 | `DERIVED_KEYS`        | `const DERIVED_KEYS`             | —                                                              | reading which keys the content index adds to a record, and which a note therefore may not author itself                                                                          |
 | `noteFile`            | `noteFile(contentBase, record)`  | `string` — the note's absolute path                            | composing an index record's `file.path` (recorded relative, for a byte-stable artifact) back into an openable absolute path                                                      |
 | `authoredFrontmatter` | `authoredFrontmatter(record)`    | `Record<string, any>` — the frontmatter without `DERIVED_KEYS` | reading back exactly what a note authored from its index record, so a pass can lint or compile from the index without reasoning about derived fields as if the author wrote them |
@@ -947,22 +950,22 @@ pages and link findings, while `collectHomepages` gathers package homepages.
 `writeHomepages` places those homepages at each package's site root. The same
 content tree can also compile into Foundry compendium packs.
 
-| Export                | Signature                                         | Returns                                                                                                                                  | Use it when                                                                                                           |
-| --------------------- | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------- |
-| `collectContentPages` | `function collectContentPages(contentBase, ctx)`  | `{{pages: object[], addressFindings: object[], fmLinkFindings: object[]}}`                                                               | The content tree's pages, and what could not be addressed.                                                            |
-| `collectHomepages`    | `function collectHomepages(contentBase, ctx)`     | `{{pages: object[], addressFindings: object[]}}` The homepage notes, in walk order, and the ones among them that could not be addressed. | The package's homepage notes — the authored page at `/<contentPackage>/`.                                             |
-| `writeHomepages`      | `function writeHomepages(outRoot, pages, config)` | {number} How many pages were written.                                                                                                    | Writes each homepage as the package root's `_index.md`.                                                               |
-| `siteGates`           | `function siteGates(pages, findings,`             | {object} The gate results and, when they pass, the built index.                                                                          | The integrity gates a site build runs before it writes anything.                                                      |
-| `emptyGates`          | `function emptyGates()`                           | {object} An all-clear gate result.                                                                                                       | The gate result of a build that ran none of them.                                                                     |
-| `gatesFailed`         | `function gatesFailed(gates)`                     | —                                                                                                                                        | Whether any gate produced a finding.                                                                                  |
-| `tableUniverse`       | `function tableUniverse(pages)`                   | {Map<string, object[]>} Package → the notes it may tabulate.                                                                             | The universe a generated table searches, grouped by package.                                                          |
-| `pageFrontmatter`     | `function pageFrontmatter(page,`                  | {object} The frontmatter to write.                                                                                                       | The frontmatter a page publishes with.                                                                                |
-| `pageDestination`     | `function pageDestination(page, { bundle })`      | —                                                                                                                                        | Where a page is written, relative to the output root: flat, or as a leaf bundle when it carries a file beside itself. |
-| `renderSitePage`      | `renderSitePage(page, options)`                   | `{body, data, resolved, tableErrors, secretErrors, wikiErrors, imageErrors}`                                                             | Transform one page with the same passes the site writer uses.                                                         |
-| `renderPages`         | `function renderPages(pages, options)`            | `{{written: number, byKind: Record<string, number>, tableErrors: object[], wikiErrors: object[]}}`                                       | Renders and writes every page.                                                                                        |
-| `resolveSitePass`     | `function resolveSitePass(name, options)`         | `{{beforeLinks?: Function}}` The bundle.                                                                                                 | Resolves `site.pass` to its bundle.                                                                                   |
-| `sitePageDecorator`   | `sitePageDecorator(config, index)`                | Function                                                                                                                                 | Add the site's infobox and being metadata to a rendered page.                                                         |
-| `buildSite`           | `buildSite({ config, sqlTables })`                | `{{gates: object, stats: object\|null, tableErrors: object[], wikiErrors: object[], mapFindings: object[], manifests: object\|null}}`    | Builds a Hugo content tree from a content tree, and reports what it found.                                            |
+| Export                | Signature                                         | Returns                                                                                                                                  | Use it when                                                                              |
+| --------------------- | ------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------- |
+| `collectContentPages` | `function collectContentPages(contentBase, ctx)`  | `{{pages: object[], addressFindings: object[], fmLinkFindings: object[]}}`                                                               | The content tree's pages, and what could not be addressed.                               |
+| `collectHomepages`    | `function collectHomepages(contentBase, ctx)`     | `{{pages: object[], addressFindings: object[]}}` The homepage notes, in walk order, and the ones among them that could not be addressed. | The package's homepage notes — the authored page at `/<contentPackage>/`.                |
+| `writeHomepages`      | `function writeHomepages(outRoot, pages, config)` | {number} How many pages were written.                                                                                                    | Writes each homepage as the package root's `_index.md`.                                  |
+| `siteGates`           | `function siteGates(pages, findings,`             | {object} The gate results and, when they pass, the built index.                                                                          | The integrity gates a site build runs before it writes anything.                         |
+| `emptyGates`          | `function emptyGates()`                           | {object} An all-clear gate result.                                                                                                       | The gate result of a build that ran none of them.                                        |
+| `gatesFailed`         | `function gatesFailed(gates)`                     | —                                                                                                                                        | Whether any gate produced a finding.                                                     |
+| `tableUniverse`       | `function tableUniverse(pages)`                   | {Map<string, object[]>} Package → the notes it may tabulate.                                                                             | The universe a generated table searches, grouped by package.                             |
+| `pageFrontmatter`     | `function pageFrontmatter(page,`                  | {object} The frontmatter to write.                                                                                                       | The frontmatter a page publishes with.                                                   |
+| `pageDestination`     | `function pageDestination(page)`                  | —                                                                                                                                        | Where a page is written, relative to the output root: `<slug>.md`, flat under the mount. |
+| `renderSitePage`      | `renderSitePage(page, options)`                   | `{body, data, resolved, tableErrors, secretErrors, wikiErrors, imageErrors}`                                                             | Transform one page with the same passes the site writer uses.                            |
+| `renderPages`         | `function renderPages(pages, options)`            | `{{written: number, byKind: Record<string, number>, tableErrors: object[], wikiErrors: object[]}}`                                       | Renders and writes every page.                                                           |
+| `resolveSitePass`     | `function resolveSitePass(name, options)`         | `{{beforeLinks?: Function}}` The bundle.                                                                                                 | Resolves `site.pass` to its bundle.                                                      |
+| `sitePageDecorator`   | `sitePageDecorator(config, index)`                | Function                                                                                                                                 | Add the site's infobox and being metadata to a rendered page.                            |
+| `buildSite`           | `buildSite({ config, sqlTables })`                | `{{gates: object, stats: object\|null, tableErrors: object[], wikiErrors: object[], mapFindings: object[], manifests: object\|null}}`    | Builds a Hugo content tree from a content tree, and reports what it found.               |
 
 ### `engine.sitePreview`
 
@@ -1226,19 +1229,20 @@ Wikilink resolution for the pack compilers. Content notes link to one another wi
 
 What a `[[…]]` **is**, before anything decides where it points. One authored link compiles to two different addresses — a Foundry `@UUID` enricher for the packs, a URL for the web — and those two destinations are the _only_ thing that legitimately differs. The syntax is the author's, and it is the same syntax whichever build is reading it.
 
-| Export                     | Signature                                                  | Returns                                                         | Use it when                                                                     |
-| -------------------------- | ---------------------------------------------------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------- |
-| `WIKILINK`                 | `const WIKILINK`                                           | —                                                               | A wikilink, as authored.                                                        |
-| `parseWikilink`            | `function parseWikilink(rawInner)`                         | {ParsedWikilink} The parts, each trimmed.                       | Split a wikilink's interior into its parts.                                     |
-| `readWikilink`             | `function readWikilink(inner, context)`                    | Typed target or literal target with diagnostic source.          | Parse a link target using complete builder Address context.                     |
-| `authoredLabel`            | `authoredLabel({ display })`                               | {string\|null} The label, or `null` when there is none to show. | The label an author actually supplied, or `null` when they supplied none.       |
-| `unlabelledLinkMessage`    | `function unlabelledLinkMessage(target)`                   | {string} The message, unpunctuated at the end as a finding is.  | What an author writing an unlabelled link is told, in one place.                |
-| `LINK_FINDING_REASONS`     | `const LINK_FINDING_REASONS`                               | —                                                               | Every way a link can fail, named once for all three resolvers.                  |
-| `unresolvedAddressMessage` | `function unresolvedAddressMessage(target)`                | {string} The message, unpunctuated at the end as a finding is.  | What an author writing an address that resolves to nothing is told.             |
-| `stubAddressMessage`       | `function stubAddressMessage(target, file)`                | {string} The message, unpunctuated at the end as a finding is.  | What an author linking to a stub is told, naming the file to open.              |
-| `ambiguousAddressMessage`  | `function ambiguousAddressMessage(target, packages`        | {string} The message.                                           | What an author writing a short address more than one package publishes is told. |
-| `linkFindingMessage`       | `linkFindingMessage({ reason, target, packages, anchor })` | {string} The message.                                           | The message for one link finding, whichever resolver found it.                  |
-| `isSamePage`               | `isSamePage({ target, anchor })`                           | {boolean} True when the link is same-page.                      | Whether a parsed link addresses a section of the page it is written on.         |
+| Export                     | Signature                                                  | Returns                                                         | Use it when                                                                                       |
+| -------------------------- | ---------------------------------------------------------- | --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------- |
+| `WIKILINK`                 | `const WIKILINK`                                           | —                                                               | A wikilink, as authored.                                                                          |
+| `parseWikilink`            | `function parseWikilink(rawInner)`                         | {ParsedWikilink} The parts, each trimmed.                       | Split a wikilink's interior into its parts.                                                       |
+| `readWikilink`             | `function readWikilink(inner, context)`                    | Typed target or literal target with diagnostic source.          | Parse a link target using complete builder Address context.                                       |
+| `authoredLabel`            | `authoredLabel({ display })`                               | {string\|null} The label, or `null` when there is none to show. | The label an author actually supplied, or `null` when they supplied none.                         |
+| `unlabelledLinkMessage`    | `function unlabelledLinkMessage(target)`                   | {string} The message, unpunctuated at the end as a finding is.  | What an author writing an unlabelled link is told, in one place.                                  |
+| `LINK_FINDING_REASONS`     | `const LINK_FINDING_REASONS`                               | —                                                               | Every way a link can fail, named once for all three resolvers.                                    |
+| `unresolvedAddressMessage` | `function unresolvedAddressMessage(target)`                | {string} The message, unpunctuated at the end as a finding is.  | What an author writing an address that resolves to nothing is told.                               |
+| `stubAddressMessage`       | `function stubAddressMessage(target, file)`                | {string} The message, unpunctuated at the end as a finding is.  | What an author linking to a stub is told, naming the file to open.                                |
+| `ambiguousAddressMessage`  | `function ambiguousAddressMessage(target, packages`        | {string} The message.                                           | What an author writing a short address more than one package publishes is told.                   |
+| `linkFindingMessage`       | `linkFindingMessage({ reason, target, packages, anchor })` | {string} The message.                                           | The message for one link finding, whichever resolver found it.                                    |
+| `isEventAnchor`            | `isEventAnchor(hit, anchor)`                               | {boolean} Whether it is an event.                               | Whether the anchor a wikilink names is one of its target's events, which a wikilink may not name. |
+| `isSamePage`               | `isSamePage({ target, anchor })`                           | {boolean} True when the link is same-page.                      | Whether a parsed link addresses a section of the page it is written on.                           |
 
 ### `engine.siteIndex`
 
@@ -1348,42 +1352,21 @@ Macros pack compiler — produces JSON pack files for the "macros" Foundry compe
 | `buildMacroEntry`     | `function buildMacroEntry(fm,`          | {MacroDocument} The Macro document.                                                                               | The compendium envelope for one Macro.                                                                                                   |
 | `Macros`              | `class Macros extends BasePackCompiler` | —                                                                                                                 | Macros pack compiler.                                                                                                                    |
 
-### `engine.mapNotes`
-
-**Map notes** — the markdown → Foundry `Scene` translation. A map note carries an _essence_: a curated, hand-owned subset of what a Scene record holds, exactly as a weapon note carries a weapon's essence rather than an Item's schema. Everything a Scene needs and nobody should have to author — the canvas defaults, the embedded `Level`, every derived region field — is synthesised here.
-
-| Export                         | Signature                                       | Returns                                                                                      | Use it when                                                                                  |
-| ------------------------------ | ----------------------------------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------- |
-| `isMapType`                    | `function isMapType(type)`                      | {boolean} True for a map type.                                                               | Whether a content note's type compiles into a Scene.                                         |
-| `MAP_SUBTYPE_PROFILES`         | `const MAP_SUBTYPE_PROFILES`                    | —                                                                                            | Per-subtype canvas defaults, emitted **explicitly** on every scene.                          |
-| `mapProfile`                   | `function mapProfile(subType)`                  | {object} The profile from {@link MAP_SUBTYPE_PROFILES}.                                      | The canvas profile for a map subType.                                                        |
-| `DEFAULT_LEVEL_ID`             | `const DEFAULT_LEVEL_ID`                        | —                                                                                            | Foundry's own id for the level a scene is created with (`Scene.metadata.defaultLevelId`).    |
-| `regionDocId`                  | `function regionDocId(sceneId, key, pinned)`    | {string} A 16-character Foundry id.                                                          | The id of one region within its scene.                                                       |
-| `behaviorDocId`                | `function behaviorDocId(regionId, key, pinned)` | {string} A 16-character Foundry id.                                                          | The id of one behaviour within its region.                                                   |
-| `regionColor`                  | `function regionColor(key)`                     | {string} A CSS hex colour.                                                                   | A region's highlight colour, derived from its key.                                           |
-| `assertPixelGeometry`          | `function assertPixelGeometry(coords, geom)`    | —                                                                                            | Reject geometry authored in grid squares where pixels belong.                                |
-| `assertGridLocation`           | `function assertGridLocation(at, geom)`         | —                                                                                            | Reject a map pin authored in pixels where grid squares belong.                               |
-| `wallRestrictions`             | `function wallRestrictions(spec, label)`        | `{{move: number, sight: number, light: number, sound: number}}` The Wall restriction fields. | Compile a wall's `blocks:` / `limits:` lists into Foundry's four numeric restriction fields. |
-| `buildShape`                   | `function buildShape(spec, geom)`               | {object} The Foundry shape record.                                                           | Compile one authored shape into a Foundry shape record.                                      |
-| `REGION_BEHAVIOR_TYPES`        | `const REGION_BEHAVIOR_TYPES`                   | —                                                                                            | The behaviour types a map note may carry (v1).                                               |
-| `BANNED_REGION_BEHAVIOR_TYPES` | `const BANNED_REGION_BEHAVIOR_TYPES`            | —                                                                                            | Behaviour types a map note may **never** carry, and why.                                     |
-| `buildScene`                   | `function buildScene(fm, ctx)`                  | {object} The Scene document, keyed for the pack.                                             | Compile a map note into a Scene document, embedded documents and all.                        |
-| `buildLevel`                   | `function buildLevel(sohl, sceneId, img`        | {object} The Level document, keyed for the pack.                                             | Synthesise the scene's single embedded Level from `img:` / `overlay:`.                       |
-| `buildWalls`                   | `function buildWalls(sohl, geom, ctx)`          | {object[]} The Wall documents.                                                               | Compile the `walls:` and `doors:` blocks into Wall documents.                                |
-| `buildLights`                  | `function buildLights(sohl, geom, ctx)`         | {object[]} The AmbientLight documents.                                                       | Compile the `lights:` block into AmbientLight documents.                                     |
-| `buildTiles`                   | `function buildTiles(sohl, geom, ctx)`          | {object[]} The Tile documents.                                                               | Compile the `tiles:` block into Tile documents.                                              |
-| `buildSounds`                  | `function buildSounds(sohl, geom, ctx)`         | {object[]} The AmbientSound documents.                                                       | Compile the `sounds:` block into AmbientSound documents.                                     |
-| `buildLocations`               | `function buildLocations(sohl, geom, ctx)`      | {object[]} The Note documents.                                                               | Compile the `locations:` block into Note documents — the map pins.                           |
-| `buildRegions`                 | `function buildRegions(sohl, geom, ctx)`        | {object[]} The Region documents.                                                             | Compile the `regions:` block into Region documents with their behaviours.                    |
+### `engine.exportedScene`
+
+An exported Foundry Scene's compile. A map note carries its Scene as exported from Foundry at `data.scene`; this passes it through, applying `data.fixup`, keying each embedded document that carries an `_id`, and binding pins marked `#anchor` to the note's own journal pages. Nothing else inside the Scene is checked.
+
+| Export               | Signature                                                                              | Returns                            | Use it when                                          |
+| -------------------- | -------------------------------------------------------------------------------------- | ---------------------------------- | ---------------------------------------------------- |
+| `buildExportedScene` | `function buildExportedScene(fm, markdown, { journalEntryId, stats, resolveAddress })` | {object} The keyed Scene document. | Compile a Foundry Scene export into a pack document. |
 
 ### `engine.scenes`
 
-Scenes pack compiler — map notes in `assets/content/` → Foundry `Scene` documents, and the `Adventure` bundles that make their references resolve. The translation itself lives in the framework-free `map-notes.mjs`; this module is the pass that walks the tree, resolves what one note says about another, and writes the JSON the compendium CLI compiles.
+Scenes pack compiler — map notes in `assets/content/` → Foundry `Scene` documents, and the `Adventure` bundles that make their pins resolve. Each map note's Scene is the one it exports from Foundry, compiled by `engine.exportedScene`; the build never constructs a Scene.
 
-| Export                    | Signature                                    | Returns                               | Use it when                                                                                                                                                                                        |
-| ------------------------- | -------------------------------------------- | ------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `collectKnownActionNames` | `function collectKnownActionNames(repoRoot)` | {Set<string>} The known action names. | Every SoHL action name this build knows about, for the `action:` warning on a region trigger.                                                                                                      |
-| `Scenes`                  | `class Scenes extends BasePackCompiler`      | —                                     | not called directly — imported and driven by `engine/generate.mjs` as the "scenes" pack compiler; walks the tree, resolves cross-scene references, and writes the JSON the compendium CLI compiles |
+| Export   | Signature                               | Returns | Use it when                                                                                                                                              |
+| -------- | --------------------------------------- | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `Scenes` | `class Scenes extends BasePackCompiler` | —       | not called directly — imported and driven by `engine/generate.mjs` as the "scenes" pack compiler; compiles each exported Scene and bundles pinned places |
 
 ### `engine.bundleNotes`
 
@@ -1970,7 +1953,7 @@ Not a JavaScript module — this subpath entry exists so tooling (bundlers, `imp
 
 ## Markup parsing modules
 
-The engine wildcard subpath also exposes the body parsers below. Historical figure API names now operate on leading captions; `:::figure` is removed.
+The engine wildcard subpath also exposes the body parsers below. Their figure exports operate on leading captions.
 
 | Module                       | Exports                                                                                      | Contract                                                                                                                                                                                                                               |
 | ---------------------------- | -------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |

package/docs/authoring/assets.md

@@ -36,7 +36,7 @@ license: CC-BY-SA-4.0
 role: portrait
 ```
 
-**A hero image is 1792×768.** `data.banner` fills one fixed strip wherever it is drawn, so every banner is cut to that size and a picture of any other size is a finding naming both sizes — resize the picture to match. That is the one size any art field requires. A map's `bgImage` sets its own scene's dimensions, so that asks nothing of a picture's dimensions either.
+**A hero image is 1792×768.** `data.banner` fills one fixed strip wherever it is drawn, so every banner is cut to that size and a picture of any other size is a finding naming both sizes — resize the picture to match. That is the one size any art field requires.
 
 `data.banner` reads in one of three states:
 

package/docs/authoring/dates-and-calendars.md

@@ -88,16 +88,20 @@ In prose, `{{dateformat "commoncal" data.born}}` prints a date in the chosen cal
 
 ## Write a recurring date
 
-A `lore` note states its dated occurrences under `data.events`, a list — a note may record a founding once and an annual festival beside it. Each entry is `{ when, until?, recurs? }`, with `when` the occurrence's anchor and first instance:
+A `lore`, `place` or `affiliation` note states its dated occurrences under `data.events`, a list — a note may record a founding once and an annual festival beside it. Each entry carries `when`, the occurrence's anchor and first instance, and optionally `until` and `recurs`; it also states a `summary`, and a note holding several gives each an `id`. The [Events reference](../reference/format-details.md#events) lists every key an entry takes.
 
 ```yaml
 data:
   events:
-    - when: 412.1
+    - id: founders
+      when: "412.1"
       recurs: { every: 1 }
-    - when: 689.5
-      until: 1203.9
+      summary: The city keeps the day of its founding.
+    - id: conjunction
+      when: "689.5"
+      until: "1203.9"
       recurs: { every: 514 }
+      summary: The great conjunction is observed from the temple roof.
 ```
 
 The first entry is annual, with no end. The second recurs every five hundred fourteen years and stopped after canonical year 1203; `recurs.every` always counts whole years on the canonical axis. In place of a period, `recurs.on` lists the dates somebody actually recorded, strictly increasing and each later than `when`:
@@ -105,12 +109,13 @@ The first entry is annual, with no end. The second recurs every five hundred fou
 ```yaml
 data:
   events:
-    - when: 326.1
+    - when: "326.1"
       recurs:
         on: ["412.1", "689.5"]
+      summary: The comet is recorded over the harbor.
 ```
 
-A build computes the next occurrence against the world's declared present the way it computes a being's age against it, and publishes it on the web page, in the content index, and in the infobox.
+A build resolves each occurrence on the canonical axis, and the content index carries the result under `resolvedDates.events`.
 
 **A day that recurs every year, with no founding date of its own, writes year `0`** — quoted, since every canonical date stating a day must be:
 
@@ -118,6 +123,7 @@ A build computes the next occurrence against the world's declared present the wa
 data:
   events:
     - when: "0.286"
+      summary: The harvest rite is kept.
 ```
 
 `when: "0.286"` is the two-hundred-eighty-sixth day of the year, every year — a harvest rite nobody dates to a founding. `recurs` is refused beside it, since the entry is already annual; `until` is allowed, and bounds how long the rite was kept.

package/docs/authoring/frontmatter.md

@@ -14,7 +14,7 @@ HeroicLands notes begin with YAML frontmatter. A file is recognized as a note wh
 shortcode: harbor
 name: { full: Harbor, aliases: [The Harbor] }
 type: lore
-subType: concept
+subType: economy
 description: A sheltered trading port.
 tags: [draft]
 data: {}
@@ -58,7 +58,7 @@ Write `government: null` for **complete anarchy**. Omitting the key leaves gover
 | Any                   | Explicit `null`     | None; complete anarchy           |
 | Any                   | Affiliation Address | None; the reference must resolve |
 
-These rules apply to every place subtype, including settlements, sites, structures, features, regions and worlds. Empty strings, numbers, lists, maps, references to another note type and unresolved references are errors. They do not declare anarchy. `domains`, `parents`, containment and capitals do not supply a government. The generated `governed_by` and `governed_places` lists use only explicit government references. Legacy affiliation `data.domains` is accepted temporarily but ignored; record any distinct ownership or influence in prose. See [government migration](../guides/government-migration.md).
+These rules apply to every place subtype, including settlements, sites, structures, features, regions and worlds. Empty strings, numbers, lists, maps, references to another note type and unresolved references are errors. They do not declare anarchy. `parents`, containment and capitals do not supply a government. The generated **Governed by** and **Governed places** sections use only explicit government references.
 
 ## Publication and summaries