@heroiclands/package-build 23.0.0 → 23.1.1

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

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

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

@@ -164,6 +164,77 @@ export function prepareSqlTables(db: object, sources: Array<{
 }): Promise<Map<string, object[]>>;
 /** Evaluate scalar SQL calls before synchronous Markdown renderers run. */
 export function prepareInlineSqlExpressions(db: any, sources: any): Promise<Map<any, any>>;
+/**
+ * Each note's generated sections — the derived lists and the event views — see
+ * {@link module:engine/generated-sections}.
+ *
+ * @param {object|undefined} db - From {@link openNotesDatabase}, over
+ *   `records`; absent, no event view is asked for.
+ * @param {object[]} records - Content-index records, of the audience the
+ *   surface publishes to.
+ * @param {string} contentBase - Root of the content tree.
+ * @param {object} [opts]
+ * @param {string} [opts.only] - One note file to give sections to; absent,
+ *   every note.
+ * @param {Map<string, object>} [opts.foreignIndex] - The fetched indexes, whose
+ *   places, affiliations and works the lists take in.
+ * @param {object} [opts.config] - The resolved configuration.
+ * @param {Map<string, Map<string, string>>} [opts.derived] - The derived
+ *   lists, from an earlier call over the same records, which are not derived
+ *   again.
+ * @returns {Promise<{sections: Map<string, string>, views: Set<string>,
+ *   derived: Map<string, Map<string, string>>}>} Note file to its sections,
+ *   joined in order; the files whose sections hold an event view's fence; and
+ *   the derived lists alone.
+ */
+export function generatedSectionsFor(db: object | undefined, records: object[], contentBase: string, { only, foreignIndex, config, derived: given }?: {
+    only?: string | undefined;
+    foreignIndex?: Map<string, object> | undefined;
+    config?: object | undefined;
+    derived?: Map<string, Map<string, string>> | undefined;
+}): Promise<{
+    sections: Map<string, string>;
+    views: Set<string>;
+    derived: Map<string, Map<string, string>>;
+}>;
+/**
+ * Join each note's generated sections to its body among the sources a
+ * preparation answers, so the fences the event views hold are answered with
+ * the author's own, in order after them. A note whose sections hold a fence
+ * and whose body holds no directive of its own joins the sources, its body
+ * read as {@link prepareTreeSqlTables} reads one.
+ *
+ * The expansion every surface runs appends the same text again, from the
+ * `generated` {@link attachGeneratedSections} sets on the note's results —
+ * see {@link module:engine/content-tables.expandContentTables}.
+ *
+ * @param {{sections: Map<string, string>, views: Set<string>}} generated -
+ *   From {@link generatedSectionsFor}.
+ * @param {Array<{source: string, markdown: string, frontmatter?: object}>} sources -
+ *   The bodies to answer, extended in place.
+ * @returns {void}
+ */
+export function joinGeneratedSections(generated: {
+    sections: Map<string, string>;
+    views: Set<string>;
+}, sources: Array<{
+    source: string;
+    markdown: string;
+    frontmatter?: object;
+}>): void;
+/**
+ * Record each note's generated sections on its prepared results, where the
+ * table expansion reads them. A note with no results of its own is given an
+ * empty set carrying them.
+ *
+ * @param {Map<string, object[]>} prepared - From {@link prepareSqlTables}.
+ * @param {{sections: Map<string, string>}} generated - From
+ *   {@link generatedSectionsFor}.
+ * @returns {void}
+ */
+export function attachGeneratedSections(prepared: Map<string, object[]>, generated: {
+    sections: Map<string, string>;
+}): void;
 /**
  * Answer every `sql` directive in a content tree.
  *
@@ -189,15 +260,19 @@ export function prepareInlineSqlExpressions(db: any, sources: any): Promise<Map<
  *   A command that also builds a link index holds them already, and deriving
  *   them twice is the duplicated-corpus failure this closes.
  * @param {"all"|"public"} [opts.audience] - Whether to exclude GM notes.
+ * @param {Map<string, object>} [opts.foreignIndex] - The fetched indexes the
+ *   generated sections take in, where the caller holds them already; absent,
+ *   they are read from the cache.
  * @returns {Promise<Map<string, object[]>|undefined>} Results by note path,
  *   carrying `inline` and `pageLists` beside them, or nothing when the tree
- *   holds no such directive.
+ *   holds no such directive and no note is given a generated section.
  */
-export function prepareTreeSqlTables(contentBase: string, { config, skipDirectories, records, audience }?: {
+export function prepareTreeSqlTables(contentBase: string, { config, skipDirectories, records, audience, foreignIndex }?: {
     config?: object | undefined;
     skipDirectories?: readonly string[] | undefined;
     records?: object[] | undefined;
     audience?: "all" | "public" | undefined;
+    foreignIndex?: Map<string, object> | undefined;
 }): Promise<Map<string, object[]> | undefined>;
 /**
  * Aliases the renderer reads rather than printing.

package/types/engine/standing-terms.d.mts

@@ -1,3 +1,13 @@
+/**
+ * The terms of a body's standing — what a membership carries, and the rungs
+ * and posts a body confers — as inner-key declarations.
+ *
+ * A leaf module, importing nothing: the note vocabulary reads these
+ * declarations as it loads, and the checks that judge what the values mean
+ * reach the vocabulary through the Address reader.
+ *
+ * @module
+ */
 /**
  * The note type a standing is held in.
  *
@@ -7,10 +17,33 @@
  */
 export const STANDING_BODY_TYPES: readonly string[];
 /**
- * The two keys one standing carries.
+ * The keys one standing carries, as inner-key declarations.
  *
- * `rank` is the level on the body's own `governance.ranks` ladder, as a number.
- * `office` is a key of its `governance.offices` map, as a string. Both are
- * optional — a membership with neither is the ordinary shape.
+ * `rank` is the level on the body's own `governance.ranks` ladder, and every
+ * membership states one. `office` is a key of its `governance.offices` map, and
+ * is stated only where the being holds a post.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
  */
+export const STANDING_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/** The keys of {@link STANDING_FIELDS}, in declared order. */
 export const STANDING_KEYS: readonly string[];
+/**
+ * The keys a rung carries, as inner-key declarations.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const RUNG_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys one row of an office's `holders` carries, as inner-key declarations.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const HOLDER_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];
+/**
+ * The keys an office written as a map carries. An office may instead be its
+ * description alone, as a string.
+ *
+ * @type {readonly import("./data-keys.mjs").InnerKeySpec[]}
+ */
+export const OFFICE_FIELDS: readonly import("./data-keys.mjs").InnerKeySpec[];

package/types/engine/standings.d.mts

@@ -101,22 +101,25 @@ export function standingsDigest(fm: object): {
     offices?: Record<string, string>;
 } | undefined;
 /**
- * How a standing reads beside the body that confers it.
+ * What a standing says before the body that confers it — `War Chief, Hárár
+ * (5), of ` — or `""` where no standing is held.
  *
  * The office leads, because it is the more particular of the two: a reader
- * meeting "War Chief" has been told the rung as well. The body closes the
- * phrase, which is the whole point of keying the entry by it — a standing with
- * no body named is the lossy form.
+ * meeting "War Chief" has been told the rung as well. The rung follows as its
+ * title with its level in parentheses, read from the body's own ladder; where
+ * the ladder names no rung at that level, or none is available, it reads as
+ * `Rank 5` and the number is not repeated. The body closes the phrase, which is
+ * the whole point of keying the entry by it — a standing with no body named is
+ * the lossy form.
  *
  * No article is supplied. One body's name reads with a "the" in front of it and
  * the next does not, and inventing one is this build editing the corpus.
  *
  * @param {object} standing - `{rank, office}`, either or both absent.
- * @param {string} body - What the body is called.
  * @param {{ranks?: Record<string, string>}} [digest] - The body's ladder.
- * @returns {string} The phrase, or the body's name where no standing is held.
+ * @returns {string} The words before the body's name, ending `of `.
  */
-export function standingPhrase(standing: object, body: string, digest?: {
+export function standingLead(standing: object, digest?: {
     ranks?: Record<string, string>;
 }): string;
 /**
@@ -127,7 +130,8 @@ export function standingPhrase(standing: object, body: string, digest?: {
  *
  * 1. the value is a map keyed by Address (or the list this window still takes);
  * 2. every key names an affiliation that resolves, once;
- * 3. the entry states a `rank`;
+ * 3. the entry states a standing at all — what a stated standing holds is the
+ *    inner-key check's, read from {@link STANDING_FIELDS};
  * 4. a `rank` is a level the named body's `governance.ranks` declares;
  * 5. an `office` is a key of that body's `governance.offices`.
  *
@@ -143,5 +147,6 @@ export function checkStandings(note: object, { index }?: {
     index?: object;
 }): object[];
 import { STANDING_BODY_TYPES } from "./standing-terms.mjs";
+import { STANDING_FIELDS } from "./standing-terms.mjs";
 import { STANDING_KEYS } from "./standing-terms.mjs";
-export { STANDING_BODY_TYPES, STANDING_KEYS };
+export { STANDING_BODY_TYPES, STANDING_FIELDS, STANDING_KEYS };

package/types/engine/wikilink-syntax.d.mts

@@ -72,6 +72,26 @@ export function authoredLabel({ display }: {
  * @returns {string} The message, unpunctuated at the end as a finding is.
  */
 export function unlabelledLinkMessage(target: string): string;
+/**
+ * Whether an anchor a link names is one of its target's events.
+ *
+ * A wikilink names a `prose` anchor; an `event` anchor is named only by the
+ * frontmatter keys that accept one. A local target carries its event ids as
+ * `eventAnchors`, a target another package publishes carries its kinded
+ * anchors as `noteAnchors`.
+ *
+ * @param {{eventAnchors?: Set<string>, noteAnchors?: Array<{slug: string,
+ *   kind?: string}>}|undefined} hit - The link's resolved target.
+ * @param {string} anchor - The anchor the link names.
+ * @returns {boolean} Whether it is an event.
+ */
+export function isEventAnchor(hit: {
+    eventAnchors?: Set<string>;
+    noteAnchors?: Array<{
+        slug: string;
+        kind?: string;
+    }>;
+} | undefined, anchor: string): boolean;
 /**
  * What an author writing an address that resolves to nothing is told.
  *

package/types/engine/wikilinks.d.mts

@@ -18,8 +18,8 @@ export function anchorPageId(noteId: string, anchorSlug: string): string;
  *
  * @param {Array<{type: string, id: string, shortcode?: string|null,
  *   name?: string, pack?: string, docPack?: string, none?: boolean,
- *   draft?: boolean, anchors?: Set<string>, anchorUuids?: Record<string,string>,
- *   docAnchorUuids?: Record<string,string>}>} docs -
+ *   draft?: boolean, anchors?: Set<string>, eventAnchors?: Set<string>,
+ *   anchorUuids?: Record<string,string>, docAnchorUuids?: Record<string,string>}>} docs -
  *   One entry per content note. `pack` / `docPack` name the packs the note's
  *   document and its documentation entry landed in; omitted, the conventional
  *   one-pack-per-type names stand in. `none` says the note declares
@@ -56,6 +56,7 @@ export function buildWikilinkIndex(docs: Array<{
     none?: boolean;
     draft?: boolean;
     anchors?: Set<string>;
+    eventAnchors?: Set<string>;
     anchorUuids?: Record<string, string>;
     docAnchorUuids?: Record<string, string>;
 }>, packageId: string, foreign?: Map<string, object>, contentPackage?: string, { assets, noIndexPackages, referenceTargets, foreignReferences }?: {

package/types/engine/yaml-lint.d.mts

@@ -22,10 +22,11 @@
  * - `no-empty-key`, `no-empty-document` — a fence or a file that parses to
  *   nothing at all.
  *
- * **GitHub workflows are exempt from `no-empty-mapping-value`**, because an
- * empty value is the language there: `on:` `push:` and `workflow_dispatch:`
- * carry their meaning by being present, and writing `push: null` to satisfy a
- * linter would be worse YAML, not better.
+ * **Workflows are exempt from `no-empty-mapping-value`**, under
+ * `.github/workflows/` and Gitea's `.gitea/workflows/` alike, because an empty
+ * value is the language there: `on:` `push:` and `workflow_dispatch:` carry
+ * their meaning by being present, and writing `push: null` to satisfy a linter
+ * would be worse YAML, not better.
  *
  * @param {object} plugin - The `eslint-plugin-yml` module.
  * @returns {object[]} A complete flat config, for `overrideConfig`.

package/types/release.d.mts

@@ -8,6 +8,10 @@
  * failure is timing-dependent, so it survives every run that happens to be
  * fast enough, which is what makes it worth being explicit about.
  *
+ * **The archive is reproducible.** Entries are written in path order with one
+ * date (`SOURCE_DATE_EPOCH` when set, otherwise 1980-01-01) and fixed
+ * permissions, so a rebuild of one staged tree is byte-identical.
+ *
  * @param {object} [opts]
  * @param {string} [opts.stageDir] - The staged package tree.
  * @param {string} [opts.outDir] - Where the release assets are written.

package/docs/guides/government-migration.md

@@ -1,52 +0,0 @@
----
-shortcode: governmentmigration
-name: { full: "Migrating place governments" }
-type: doc
-subType: howto
----
-
-# Migrating place governments
-
-A place's `data.government` is the sole declaration of government. Its type is `Address`, with default target type `affiliation`. Name one governing affiliation, or write explicit `null` for complete anarchy. Omission means unknown. The website derives `governed_by` on a place and `governed_places` on its governing affiliation from resolved references across local and fetched indexes. Neither containment nor organizational parents supplies a government.
-
-```yaml
-type: place
-data:
-  government: temple
-```
-
-A temple can be a government when it actually governs the place; so can a company, house or polity. Naming land in an old affiliation `data.domains` list never makes that body a government automatically. When old lists overlap, choose the one body that actually governs each place. Do not choose from subtype or list order. Leave government absent if the answer is unknown; do not write null merely to silence a warning.
-
-## Legacy input and output changes
-
-Legacy affiliation `data.domains` is temporarily accepted without a finding so existing trees can migrate. It is ignored: it no longer creates affiliation Domains infobox rows, metadata-index `domains`, SoHL `system.domain`, or website `held_by` and `holdings`. New notes should omit it. A fetched older system schema can still declare `system.domain`; the schema check then reports an advisory that the field receives its system default. No new government is inferred from that default. There is no new authored holdings or tenure field. Preserve distinct ownership, subordinate tenure, property rights or influence in the note's prose, with links where useful, before deleting the old list.
-
-The tenure-based `over-held land` population advisory is retired. Geographical `contains` and the remaining population checks continue to use place parents unchanged. Explicit null remains null in published metadata and displays Complete anarchy; omission stays absent. Neither appears in a governing body's reverse list.
-
-## Inventory behind the migration
-
-The baseline at commit `ada039d` contains 15 production files, six documentation files and nine test files mentioning `domains`, `held_by` or `holdings` (137, 70 and 99 occurrences respectively). Domains alone appears in 20 files across 127 matching lines. The active consumers are author declarations/schema and infoboxes, metadata indexes, SoHL `system.domain`, direct and reverse website tenure lists, site previews and the polity population advisory. Public holdings APIs and generated reference documentation describe these outputs.
-
-The migrated Thalorna baseline has 3,171 notes: 637 places, of which 191 declare government, 446 omit it and none declare null. Its 133 affiliations still carry 196 legacy domains claims covering 191 distinct places: 125 polities account for 184 claims, seven faith traditions for 11 and one order for one. Two places have overlapping claims (`pssshrines`: two; `aukhelathrgq`: five). These are reasons to review actual governance rather than infer it from legacy claims.
-
-Those consumers combined governance with independently meaningful direct tenure: houses holding manors, temples and companies claiming property, overlapping provincial and imperial claims. This migration deliberately replaces structured tenure displays with government derived from places, rather than converting every old claim into government. Independent historical facts remain supported in prose. Acceptance of legacy input is transitional; enforced removal will require separate author guidance.
-
-## SQL queries
-
-Queries that read affiliation `data.domains` must instead join each place's explicit government to the affiliation's address. For example, to list the governing bodies of places directly within a region:
-
-```sql
-SELECT DISTINCT affiliation.address.slug AS _ref,
-       affiliation.name.full AS "Government"
-FROM notes affiliation
-JOIN notes place
-  ON place.data.government = concat(affiliation.package, '-note-affiliation-', affiliation.shortcode)
-WHERE affiliation.type = 'affiliation'
-  AND place.type = 'place'
-  AND list_contains(place.data.parents, 'thalorna-note-place-aelwyth')
-ORDER BY affiliation.name.full COLLATE NOCASE
-```
-
-The equality above uses the canonical journal addresses in the local `notes` table. Explicit Item addresses may use a system segment such as `sohl`; include that address when joining those references. Government lists generated by the site already handle Item and journal addresses for the same page. Null and omitted government do not match the join. A query that can legitimately select no places should declare `{allow-empty=true}` on its SQL fence.
-
-The real consumer regression migrated fourteen SQL query sites, including ten Government columns that formerly read reverse domains and four polity queries. Keeping the source field accepted does not preserve queries that depend on its retired semantics.

package/engine/itinerary-scenes.mjs

@@ -1,166 +0,0 @@
-/*
- * SPDX-License-Identifier: GPL-3.0-or-later
- */
-
-/** Gridless Foundry Scenes drawn from place relations. */
-
-import fs from "node:fs";
-import path from "node:path";
-import { resolvePackageBuildConfig } from "../config.mjs";
-
-import { buildMaps, relatedPlaces } from "./map-build.mjs";
-import { renderDot } from "./map-graphviz.mjs";
-import { mapWorld } from "./map-places.mjs";
-import { loadForeignIndexes } from "./metadata-index.mjs";
-import { authoredFrontmatter, isNoteRecord } from "./index-records.mjs";
-import { buildScene } from "./map-notes.mjs";
-import { buildJournalEntry } from "./journals.mjs";
-import { imageDimensions } from "./asset-types.mjs";
-import { makeId } from "./ids.mjs";
-import { stripAdventureKeys } from "./bundle-notes.mjs";
-
-/** GraphViz's plain coordinates, converted to pixel positions on its PNG. */
-export function pinPositions(plain, width, height) {
-    const graph = /^graph\s+\S+\s+(\S+)\s+(\S+)/m.exec(plain);
-    if (!graph) throw new Error("GraphViz emitted no graph size for itinerary pins");
-    const graphWidth = Number(graph[1]);
-    const graphHeight = Number(graph[2]);
-    if (!(graphWidth > 0 && graphHeight > 0)) {
-        throw new Error("GraphViz emitted an invalid graph size for itinerary pins");
-    }
-    const positions = new Map();
-    for (const line of plain.split("\n")) {
-        const match = /^node\s+(?:"(p_[^"]+)"|(p_\S+))\s+(\S+)\s+(\S+)/.exec(line);
-        if (!match) continue;
-        const shortcode = (match[1] ?? match[2]).slice(2);
-        positions.set(shortcode, {
-            x: Math.round((Number(match[3]) / graphWidth) * width),
-            y: Math.round((1 - Number(match[4]) / graphHeight) * height),
-        });
-    }
-    return positions;
-}
-
-/** The compiled local journals a generated Adventure can import with its Scenes. */
-function localJournals(dirs) {
-    const byId = new Map();
-    for (const dir of dirs) {
-        if (!fs.existsSync(dir)) continue;
-        for (const file of fs.readdirSync(dir)) {
-            if (!file.endsWith(".json")) continue;
-            const doc = JSON.parse(fs.readFileSync(path.join(dir, file), "utf8"));
-            if (String(doc._key ?? "").startsWith("!journal!")) byId.set(doc._id, doc);
-        }
-    }
-    return byId;
-}
-
-/**
- * Emit backgrounds into the staged package and return Scenes and the journals
- * their pins need. The caller writes them into its Scene and Adventure packs.
- */
-export function buildItineraryScenes({
-    config,
-    records,
-    contentBase,
-    journalSourceDirs = [],
-    stats,
-    foreign = loadForeignIndexes(config, [config.contentPackage]),
-}) {
-    const buildConfig = resolvePackageBuildConfig(config);
-    const world = mapWorld({ records, foreignIndex: foreign.index, contentBase, config });
-    const centres = relatedPlaces(world.places).filter((sc) => world.places.get(sc)?.local);
-    const findings = foreign.stale.map((stale) => ({
-        file: contentBase,
-        severity: "warning",
-        message: `the ${stale.package} content index is unavailable, so itinerary maps omit its places: ${stale.reason}`,
-    }));
-    const assetDir = path.resolve(
-        config.rootDir,
-        buildConfig.stageDir,
-        "assets/maps/generated-itineraries",
-    );
-    fs.rmSync(assetDir, { recursive: true, force: true });
-    if (!centres.length) return { scenes: [], journal: [], findings };
-
-    const outDir = path.resolve(config.rootDir, "build/map/foundry");
-    fs.rmSync(outDir, { recursive: true, force: true });
-    const drawn = buildMaps({ world, outDir, from: centres });
-    findings.push(...drawn.findings);
-    fs.mkdirSync(assetDir, { recursive: true });
-
-    const localRecords = new Map();
-    for (const record of records) {
-        if (!isNoteRecord(record) || record.type !== "place") continue;
-        localRecords.set(String(record.shortcode).toLowerCase(), authoredFrontmatter(record));
-    }
-    const compiledJournals = localJournals(journalSourceDirs);
-    const imported = new Map();
-    const scenes = [];
-    for (const centre of centres) {
-        const dot = path.join(outDir, `from-${centre}.dot`);
-        const png = path.join(assetDir, `from-${centre}.png`);
-        const plain = path.join(outDir, `from-${centre}.plain`);
-        renderDot(dot, png, { engine: "neato", format: "png", nop: 2, dpi: 150 });
-        renderDot(dot, plain, { engine: "neato", format: "plain", nop: 2 });
-        const size = imageDimensions(png, ".png");
-        if (!size) throw new Error(`${png} carries no readable PNG size`);
-        const { width, height } = size;
-        const positions = pinPositions(fs.readFileSync(plain, "utf8"), width, height);
-        const sceneId = makeId("itinerary-scene", `${config.contentPackage}:${centre}`);
-        const src = `${buildConfig.packageKind}/${buildConfig.packageId}/assets/maps/generated-itineraries/from-${centre}.png`;
-        const scene = buildScene(
-            {
-                id: sceneId,
-                name: { full: `From ${world.places.get(centre).name}` },
-                subType: "regionalmap",
-                sohl: { dimensions: [width, height], pxPerGrid: 100 },
-                data: { bgImage: src },
-            },
-            { art: () => src, stats },
-        );
-        scene.grid.distance = 1;
-        scene.grid.units = "";
-        for (const [shortcode, at] of positions) {
-            const place = world.places.get(shortcode);
-            if (!place) continue;
-            let journal;
-            if (place.local) {
-                journal = compiledJournals.get(localRecords.get(shortcode)?.id);
-            } else {
-                const ref = foreign.index.get(place.address);
-                if (ref?.uuid && /\.JournalEntry\./.test(ref.uuid)) {
-                    const id = makeId("itinerary-foreign-journal", place.address);
-                    journal = buildJournalEntry({
-                        id,
-                        name: place.name,
-                        markdown: `@UUID[${ref.uuid}]{Open ${place.name}}`,
-                        stats,
-                    });
-                }
-            }
-            if (!journal) {
-                findings.push({
-                    file: place.file ? path.join(contentBase, place.file) : contentBase,
-                    severity: "warning",
-                    message: `place "${shortcode}" has no addressable JournalEntry, so its itinerary label has no Foundry pin`,
-                });
-                continue;
-            }
-            imported.set(journal._id, stripAdventureKeys(journal));
-            const id = makeId("itinerary-note", `${sceneId}:${shortcode}`);
-            scene.notes.push({
-                _id: id,
-                entryId: journal._id,
-                pageId: null,
-                x: at.x,
-                y: at.y,
-                text: place.name,
-                iconSize: 32,
-                _key: `!scenes.notes!${sceneId}.${id}`,
-            });
-        }
-        scenes.push(scene);
-    }
-    return { scenes, journal: [...imported.values()], findings };
-}