@heroiclands/package-build 22.4.6 → 22.4.7

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @heroiclands/package-build
 
+## 22.4.7
+
+### Patch Changes
+
+Every place page that states a border or a route, or is named in one, carries the map from that place: `from-<shortcode>.svg` beside the page and `map:` naming it in the front matter, with every place name on it a link to that place's page. GraphViz draws it; when GraphViz is not installed the site build says so once and writes every page without a map, and `site.maps: false` draws none.
+
+A place's page carries what lies within it and who holds it, and an affiliation's page carries what it holds, read from the `parents` and `domains` the notes already state — a dependency's places and affiliations included. `content-build lint` warns of unheld land: a settlement, site or structure that no affiliation's `domains` names.
+
+A `place` note can state a settlement's market class: `data.market`, a whole number from 1 to 6 beside `population`. `1` is a hamlet, with no market beyond what neighbours trade among themselves; `2` a village and its weekly market; `3` a town with several trades working full time; `4` a market town, its chartered fair and its moneylender; `5` a city, where anything ordinary can be had in quantity; `6` a great city that banks, imports as a matter of course, and is the market from which the other markets buy. The key is optional, and a value off the scale is reported at the line that states it rather than rounded onto a class nobody wrote.
+
 ## 22.4.6
 
 ### Patch Changes

package/CONTENT.md

@@ -1183,6 +1183,25 @@ parent or child, or a pair listed twice by one mode. Each finding lands on the
 entry that states it. The keys, the sets and the days scale are specified under
 `type: place` in `docs/content-format.md`.
 
+**A settlement is held by someone.** An affiliation's `domains` names the
+places it holds, and a `place` of subType `settlement`, `site` or `structure`
+that no affiliation's `domains` names — in this tree or in a fetched index —
+is a warning, `unheld land`, at the note's `type:` line, so a gap in tenure
+shows. A region is held through its polity's `domains` and a feature by
+nobody, so neither is checked.
+
+**A settlement's market class is one of six.** `data.market` states what trade
+a settlement supports — `1` a hamlet, with no market beyond what neighbours
+trade among themselves; `2` a village and its weekly market; `3` a town with
+several trades working full time; `4` a market town, its chartered fair and its
+moneylender; `5` a city, where anything ordinary can be had in quantity; `6` a
+great city that banks, imports as a matter of course, and is the market from
+which the other markets buy. The numbers order the steps and do nothing else, so a value off the
+scale is an error at the value that states it rather than a number rounded onto
+a class the author did not write. The key is optional and the lint checks no
+`subType` condition, as it checks none for `population`. The scale is stated
+under `type: place` in `docs/content-format.md`.
+
 Nothing here writes. A check reports and an author fixes.
 
 **`content-build map` draws what those keys state.** `--tree` is the author's
@@ -2409,6 +2428,96 @@ The theme's `related.html` partial reads both lists and renders them as one
 `related` is derived, never authored: what links to a page is a fact about
 every other page in the tree. A note that writes one has it replaced.
 
+### A place page says what lies within it and who holds it; an affiliation page says what it holds
+
+Two keys the notes already carry answer three questions a reader asks of a
+page. A place's `data.parents` is geography — what it sits within — and an
+affiliation's `data.domains` is tenure — what it holds. The build reads both
+across the tree and every fetched index, inverts them, and writes each page
+the lists that concern it, shaped like `related`:
+
+```yaml
+# on a place
+contains: # every place whose `parents` names this one
+  - title: Khaset-Mehtet
+    url: /thalorna/place-khasetmehtet/
+    type: place
+    subType: settlement
+held_by: # every affiliation whose `domains` names this one
+  - title: The Nome of Ankhsetun
+    url: /thalorna/affiliation-nomenkhstn/
+    type: affiliation
+    subType: polity
+
+# on an affiliation
+holdings: # every place its `domains` names
+  - title: Ankhsetun
+    url: /thalorna/place-ankhsetunnome/
+    type: place
+    subType: region
+```
+
+- **`contains` and `holdings` are sorted by `subType`, then `title`**;
+  `held_by` by `title`. An entry carries `subType` where the note declares
+  one.
+- **A key is present only when it has an entry.** A place nobody holds and
+  nothing sits within carries neither key; an affiliation whose `domains` is
+  empty carries no `holdings`. The theme's silent-disappear convention, kept
+  at the source.
+- **`domains` names what an affiliation holds directly, and is never
+  expanded.** A polity whose `domains` names a region holds the region; the
+  settlements within it are reached through the region's `contains`, and are
+  not repeated in the polity's `holdings`. Tenure runs through
+  `affiliation.parents` — a house of its earl, an earl of the crown — and
+  geography through `place.parents`. A subinfeudated manor sits in one region
+  by the second and under a lord of another polity by the first, and both
+  pages say so.
+- **A dependency's places and affiliations take part.** A fetched index entry
+  carries the `parents` and `domains` its record stated, so a place another
+  package publishes is listed within a local region, and a house another
+  package publishes is named on the local manor it holds. A local note
+  declaring a shortcode shadows a fetched entry declaring the same one.
+- **`url` composes `<base><slug>/`**, as every `related` entry does.
+
+All three are derived, never authored: a note that writes one has it
+replaced. The theme renders each list as a table on the page.
+
+### A place page carries the map from that place
+
+A place that states a border or a route, or is named in one, has a map from
+it — the drawing `content-build map --from` makes, with the place at the
+centre and each neighbour at its bearing. The site build draws that map for
+every such place and writes it with the page: the page is a leaf bundle,
+`place-<shortcode>/index.md`, the drawing sits beside it as
+`from-<shortcode>.svg`, and the front matter names it:
+
+```yaml
+map: from-kthrmr.svg
+```
+
+The theme's "From here" panel reads the key, inlines the file as a page
+resource, and so every place name on the map is a link to that place's page.
+What the build guarantees:
+
+- **The address does not move.** A bundled page states the same `url` a flat
+  one does, `/<slug>/`, so `place-kthrmr/index.md` publishes exactly where
+  `place-kthrmr.md` would.
+- **Every name links through the site base.** The map is drawn with the base
+  the pages are served under, so each `href` composes `<base><slug>/` the way
+  every other href the build renders does.
+- **It is written for inlining.** No XML prologue, no DOCTYPE, no comment, no
+  reference to anything outside the file; the root carries a `viewBox` and no
+  fixed width or height, so the theme sizes it to the column.
+- **A place with no relation carries nothing**: no file beside it, no `map`
+  key, and the page stays a flat file. So does every page that is not a place.
+- **A site never fails for want of a map.** GraphViz draws; when it is not
+  installed the build says so once, as a warning naming what to install, and
+  every page is written as it would be without maps. `site.maps: false` in
+  `package-build.config.yaml` draws nothing and asks nothing of GraphViz.
+
+`map` is derived, never authored: a note that writes one has it replaced when
+the build draws a map, and dropped when there is none to draw.
+
 ### Why the output location is fixed
 
 The content mount is a build artifact and is **deleted on every run**, so that a

package/bin/content-build.mjs

@@ -1515,7 +1515,8 @@ function pdfCommand() {
  * wikilink resolution, code-fence protection and the foreign-manifest merge —
  * happens here, from configuration. So does the Hugo configuration: the whole
  * source tree Hugo reads lands under `build/hugo/`, and the consumer's script
- * runs Hugo over it.
+ * runs Hugo over it. With `site.maps` on and GraphViz installed, every place
+ * page with a border or a route carries the map from that place.
  *
  * **The Hugo configuration is generated before anything is written.** Its
  * sources — `package.json`'s `homepage`, the cached navigation, the installed
@@ -1653,10 +1654,17 @@ function siteCommand() {
                     return;
                 }
 
+                // What drawing the maps found: warnings, every one. A site
+                // never fails for want of a map, so none of these touches the
+                // exit code — GraphViz absent is one line naming what to
+                // install, and every page is written as it would be without.
+                for (const f of result.mapFindings) emitDiagnostic(f);
+
                 const s = result.stats;
                 log.info(
                     `wrote ${s.homepages ?? 0} homepage(s) + ` +
-                        `${s.content ?? 0} content page(s) to ` +
+                        `${s.content ?? 0} content page(s), ` +
+                        `${s.maps ?? 0} with a map, to ` +
                         `${path.relative(process.cwd(), s.out)}`,
                 );
                 const { file } = writeHugoConfig(config, hugo);

package/content-config.mjs

@@ -772,6 +772,7 @@ const SITE_KEYS = [
     "notfound",
     "hugo",
     "search",
+    "maps",
 ];
 const SITE_NOTFOUND_KEYS = ["tagline", "sitenoun", "heroimage", "links"];
 const SITE_NOTFOUND_LINK_KEYS = ["title", "url", "text"];
@@ -1711,9 +1712,11 @@ const SITE_INDEX_MESSAGE =
  * shared with the link manifest so the two cannot disagree about where a
  * page is.
  *
- * `search` is the one switch here: whether `package-build site-root` writes a
- * search index beside the rendered pages. On by default — every site carries
- * one unless it says otherwise.
+ * Two switches sit here, both on by default. `search` is whether
+ * `package-build site-root` writes a search index beside the rendered pages.
+ * `maps` is whether `content-build site` draws the map from each place that
+ * states a border or a route and writes it into that place's page — a site
+ * carries both unless it says otherwise.
  *
  * **What the site publishes is the homepage and the content tree, and nothing
  * beside them.** A page of documentation is a note — `type: doc`, addressed
@@ -1739,6 +1742,7 @@ function normalizeSite(value) {
         notfound: null,
         hugo: Object.freeze({}),
         search: true,
+        maps: true,
     });
     if (value === undefined) return empty;
     if (!isPlainObject(value)) fail("site", "must be a mapping");
@@ -1795,6 +1799,7 @@ function normalizeSite(value) {
         notfound: normalizeSiteNotfound(input.notfound),
         hugo: normalizeSiteHugo(input.hugo),
         search: optionalBoolean(input.search, "site.search", true),
+        maps: optionalBoolean(input.maps, "site.maps", true),
     });
 }
 

package/docs/api.md

@@ -429,6 +429,30 @@ What a place is next to (`data.borders`) and reachable from (`data.routes`): the
 | `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            |
 
+### `engine.holdings`
+
+What lies within a place, who holds it, and what an affiliation holds — read off `data.parents` and `data.domains` across this package and every fetched index, inverted into the `contains`, `held_by` and `holdings` lists the site build writes — and the tenure check `content-build lint` runs on a place.
+
+| Export                 | Signature                            | Returns                 | Use it when                                                                                                                  |
+| ---------------------- | ------------------------------------ | ----------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
+| `HOLDINGS_KEYS`        | `const HOLDINGS_KEYS`                | `readonly string[]`     | the three derived keys — `contains`, `held_by`, `holdings` — which a note cannot author                                      |
+| `HELD_SUBTYPES`        | `const HELD_SUBTYPES`                | `readonly string[]`     | the place subTypes tenure is checked on — `settlement`, `site`, `structure`                                                  |
+| `holdingsNode`         | `holdingsNode(fm, { title, url })`   | `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)`               | `Map<string, Holdings>` | inverting `parents` and `domains` into each page's sorted lists, keyed by URL, for every page with at least one entry        |
+| `checkHeld`            | `checkHeld(note, { index })`         | `object[]`              | linting a place's tenure — a settlement, site or structure no affiliation's `domains` names is a warning at its `type:` line |
+
+### `engine.marketClass`
+
+What trade a settlement supports (`data.market`): the six-step scale, stated once for the lint, the author-facing reference and the specification, and the check that holds a note's value to it.
+
+| Export           | Signature              | Returns             | Use it when                                                                                       |
+| ---------------- | ---------------------- | ------------------- | ------------------------------------------------------------------------------------------------- |
+| `MARKET_CLASSES` | `const MARKET_CLASSES` | `readonly object[]` | the scale in order, each step its `value`, the `name` a settlement of it goes by, and its `trade` |
+| `isMarketClass`  | `isMarketClass(value)` | `boolean`           | asking whether an authored value names a class, a quoted number included                          |
+| `marketClass`    | `marketClass(value)`   | `object\|undefined` | the class a value names, for rendering what a number means                                        |
+| `checkMarket`    | `checkMarket(note)`    | `object[]`          | linting a place's `market` — a value off the scale, located at the value that states it           |
+
 ### `engine.mapPlaces`
 
 The places a map is drawn from — this package's index records and every fetched dependency's entries, read through one shape — and what their `parents` say: the world, the continents, each place's continent, and everything the containment tree can get wrong, reported as findings located at the entry that states it.
@@ -437,6 +461,7 @@ The places a map is drawn from — this package's index records and every fetche
 | --------------------- | ---------------------------------------------------------------- | ------------- | ------------------------------------------------------------------------------------------------------------------------ |
 | `placesFromRecords`   | `placesFromRecords(records, { contentBase, base })`              | `MapWorld`    | reading this package's places and polities out of its index records, with a page URL each where a site base is given     |
 | `loadMapWorld`        | `loadMapWorld({ config, contentBase, base, problems })`          | `MapWorld`    | loading the world a map is drawn from — this package's index and every declared dependency's                             |
+| `mapWorld`            | `mapWorld({ records, foreignIndex, contentBase, base, config })` | `MapWorld`    | the same world out of records and indexes a caller already holds, as the site build does                                 |
 | `analyzeContainment`  | `analyzeContainment(places, polities)`                           | `Containment` | finding the world, the continents, each place's continent and the anomalies of `parents`                                 |
 | `subtreeOf`           | `subtreeOf(analysis, root)`                                      | `Set<string>` | every place beneath one, by following `parents` downward                                                                 |
 | `containmentFindings` | `containmentFindings(analysis, places, { contentBase, config })` | `object[]`    | the anomalies as `file:line:column: severity: message` findings — no parent, an unresolved parent and a cycle are errors |
@@ -485,6 +510,7 @@ GraphViz, as the map command reaches it: a build-time tool of that command alone
 | Export                   | Signature                                               | Returns             | Use it when                                                                                |
 | ------------------------ | ------------------------------------------------------- | ------------------- | ------------------------------------------------------------------------------------------ |
 | `GRAPHVIZ_ENGINES`       | `const GRAPHVIZ_ENGINES`                                | `readonly string[]` | the engines the map command may ask for — `dot`, `twopi`, `neato`                          |
+| `GRAPHVIZ_INSTALL`       | `const GRAPHVIZ_INSTALL`                                | `string`            | what installs GraphViz, as the clause every "not installed" message ends with              |
 | `findGraphviz`           | `findGraphviz(engine, { env, fallbacks })`              | `string\|undefined` | finding an engine's binary on `PATH` or in the directories a package manager installs into |
 | `graphvizMissingMessage` | `graphvizMissingMessage(engine)`                        | `string`            | saying an engine is not installed, and what installs it                                    |
 | `renderDot`              | `renderDot(dotPath, outPath, { binary, format, args })` | `{warnings}`        | rendering a `.dot` file, the engine's warnings returned and a non-zero exit thrown         |
@@ -500,6 +526,16 @@ GraphViz, as the map command reaches it: a build-time tool of that command alone
 | `relatedPlaces` | `relatedPlaces(places)`                                                                                                                               | `string[]`                     | every place that states, or is named in, a border or a route                  |
 | `buildMaps`     | `buildMaps({ world, outDir, tree, root, from, chart, horizon, travel, engine, rankdir, nodesep, ranksep, scale, polities, locate, requireGraphviz })` | `{written, findings, skipped}` | drawing any of the four from a loaded world                                   |
 
+### `engine.siteMaps`
+
+The map from each place, drawn for the site: `content-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`. GraphViz absent is one warning and no map; `site.maps: false` draws none.
+
+| 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, locate })` | `{maps, findings}` | drawing the map from every related place of this package, keyed by the URL of the page that carries it          |
+
 ### `engine.systems`
 
 The closed registry of system ids, and the `none` that stands for no system at all. An unknown system value is an error; adding a system is a data change to this registry rather than a hardcoded set scattered through the pipeline.
@@ -694,20 +730,20 @@ The toolchain's own content index — the files it ships, addressed. Every other
 
 Publishing a content tree as a website. Compiling a content tree into compendium packs is `content-build package compile`. Publishing the _same tree_ as a website was a script each consumer wrote for itself — 473 code lines in `sohl` and 462 in `sohl-thalorna`, 87 of them identical — and the copies drifted in ways neither repository could see. `sohl-thalorna` reimplemented four things this package already exported, not because it needed different behaviour but because its script predates the extraction. That is the failure a command removes: a consumer cannot accidentally reimplement one.
 
-| 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.                      |
-| `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.                                        |
-| `buildSite`           | `buildSite({ config, sqlTables })`                | {{gates: object, stats: object\|null, tableErrors: object[], wikiErrors: 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, { bundle })`      | —                                                                                                                                      | Where a page is written, relative to the output root: flat, or as a leaf bundle when it carries a file beside itself. |
+| `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.                                                                                   |
+| `buildSite`           | `buildSite({ config, sqlTables, locate })`        | {{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.contentLint`
 

package/docs/configuration.md

@@ -770,6 +770,7 @@ Any other key under `docs.itemFields` is refused:
 | `site.notfound`    | object   | `null`                                      |
 | `site.hugo`        | object   | `{}`                                        |
 | `site.search`      | boolean  | `true`                                      |
+| `site.maps`        | boolean  | `true`                                      |
 
 How much of a package reaches the web at all is **not** here — it is
 [`publish.site`](#publish). `site` is framing: which named pass bundle
@@ -819,7 +820,7 @@ published. A `site.out` is refused by name:
 
 > ``package-build config: `site` must be a mapping.``
 
-> ``package-build config: `site.<key>` is not a recognized option (expected one of: base, assets, description, packages, pass, passOptions, notfound, hugo, search).``
+> ``package-build config: `site.<key>` is not a recognized option (expected one of: base, assets, description, packages, pass, passOptions, notfound, hugo, search, maps).``
 
 `site.assets` is the host every package's imagery is served from, and it is
 the one address in this file that is not this repository's own. A note names
@@ -950,6 +951,24 @@ site:
 
 > ``package-build config: `site.search` must be a boolean.``
 
+`site.maps` is whether every place page carries the map from that place. On
+by default: `content-build site` draws the map `content-build map --from`
+draws — the place's borders and routes, each neighbour at its bearing — for
+every place that states a border or a route or is named in one, lays it beside
+the page as `from-<shortcode>.svg`, and names the file in the page's front
+matter as `map`, which the theme inlines so every place name on it is a link
+to that place's page. A place with no relation carries no map and no key.
+GraphViz draws; when it is not installed the build says so once, as a
+warning, and writes every page as it would without maps — a site never fails
+for want of one. `false` draws nothing and asks nothing of GraphViz.
+
+```yaml
+site:
+  maps: false
+```
+
+> ``package-build config: `site.maps` must be a boolean.``
+
 ### The generated Hugo configuration
 
 `content-build site` writes `build/hugo/hugo.toml` on every run. Every value

package/docs/content-format.md

@@ -2440,6 +2440,23 @@ subType `deity` covers a god's nature, domains, epithets and aspects in prose.
 That frees the name for the territorial sense, which earns it: every affiliation
 subType holds sway somewhere, while the divine sense applies to one.
 
+**`domains` names what the affiliation holds directly**, and nothing beneath
+it. A polity whose `domains` names a region holds the region; the settlements
+within it are the region's, reached through its `contains`, and are not
+repeated here. A house holds its manors and names each; the crown holds the
+realm and names the realm. What lies below a holder is answered by the two
+hierarchies together — `place.parents` for where a place sits, and
+`affiliation.parents` for whom a holder answers to — so a subinfeudated manor
+sits in one region by the first and under a lord of another polity by the
+second, and both pages say so.
+
+The website reads `domains` across the package and every fetched index and
+writes the affiliation's page a `holdings` list — every place its `domains`
+names, each entry `{ title, url, type, subType }`, sorted by `subType` then
+`title`, and absent when `domains` names nothing. Every place it names carries
+the affiliation back in `held_by`. Both are derived; a note that writes one has
+it replaced.
+
 If `sohl` is present, this becomes an `affiliation` item.
 
 | shared source    | → sohl             | → hm3 |
@@ -3087,9 +3104,38 @@ three maps, and none of those maps needs to know it is a keep.
 | `lore`          | `WikiLink[]`                                        | Lore concerning this place — its peoples, its law, its calendar, its history |
 | `parents`       | `WikiLink[]`                                        | Enclosing places within which this place is located                          |
 | `population`    | `number`                                            | Approximate population (precision 2 significant digits)                      |
+| `market`        | `number`                                            | Market class, 1 to 6 — what trade a settlement supports                      |
 | `borders`       | `{ to, bearing }[]`                                 | Places sharing a frontier with this one, and where each lies from here       |
 | `routes`        | `{ to, bearing, mode, days, terrain?, leagues? }[]` | Journeys from this place's centre to another place                           |
 
+#### What a settlement's market supports
+
+`population` states how many people a settlement holds; `market` states what a
+traveller can buy there. Those are different questions — two settlements of
+eight hundred are a different proposition when one holds a weekly market and
+the other a chartered fair with a moneylender — so a note states both, either,
+or neither.
+
+The value is a **class**, not a measurement. The numbers order six steps and do
+nothing else: a `5` is not a market two fifths larger than a `3`, it is a city
+rather than a town. `content-build lint` refuses a value off the scale instead
+of rounding it onto one, so a reader can trust that a number means the same
+thing on every page.
+
+| `market` value | the settlement is | what can be had there                                                                             |
+| -------------- | ----------------- | ------------------------------------------------------------------------------------------------- |
+| `1`            | a hamlet          | no market — what neighbours trade among themselves                                                |
+| `2`            | a village         | a weekly market: staples, a smith, what a household cannot make                                   |
+| `3`            | a town            | a regular market, most common goods, several trades working full time                             |
+| `4`            | a market town     | a chartered fair, goods carried from a week away, a moneylender                                   |
+| `5`            | a city            | anything ordinary, in quantity; foreign goods; a guild structure                                  |
+| `6`            | a great city      | the rare and the imported as a matter of course; banking; the market from which other markets buy |
+
+The key is meaningful on a settlement, and the lint checks no `subType`
+condition — as it checks none for `population`. Which places a fact says
+something about is the author's judgement, and the `data:` container is closed
+per type rather than per subType.
+
 #### Where a place is, in relation to other places
 
 `parents` states what a place is **within**. Two more properties state what
@@ -3187,6 +3233,31 @@ closed set, and each finding is located at the entry that states it.
 | `river`         | boat               |
 | `lake`          | boat               |
 
+#### What lies within a place, and who holds it
+
+`parents` states what a place is within; an affiliation's `domains` states
+what it holds. The website reads both across the package and every fetched
+index and writes each place's page two lists, each entry
+`{ title, url, type, subType }` and each absent when empty:
+
+- `contains` — every place whose `parents` names this one, sorted by
+  `subType` then `title`. A region lists its settlements, sites, structures
+  and features; a settlement lists the structures within it.
+- `held_by` — every affiliation whose `domains` names this one, sorted by
+  `title`.
+
+Both are derived; a note that writes one has it replaced. **`domains` is
+never expanded**: a region held by a polity lists the polity in `held_by`, and
+a settlement within that region lists only the house or order whose `domains`
+names it — its lord's lord is reached through `affiliation.parents`.
+
+**A settlement, a site or a structure is held by someone.** One of those that
+no affiliation's `domains` names — in this package or in a fetched index — is
+a warning from `content-build lint`, `unheld land`, located at the note's
+`type:` line, so a gap in tenure shows while a note is written. A `world`, a
+`region` and a `feature` are exempt: a region is held through its polity's
+`domains`, and a river by nobody.
+
 **A place declares only what is true of ground.** Four properties were removed
 because they were true of something else, and each removal has a home to go to.
 

package/engine/frontmatter-lint.mjs

@@ -1424,6 +1424,8 @@ export function lintNote(
             if (typeof field.check !== "function") continue;
             findings.push(...field.check(note, { index }));
         }
+        // A check the type declares of the whole note, with the same index.
+        if (typeof entry.check === "function") findings.push(...entry.check(note, { index }));
     }
 
     const fields = authoredFields(schema);