@heroiclands/package-build 22.14.4 → 22.15.0

package/engine/exported-scene.mjs

@@ -0,0 +1,230 @@
+/*
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/** Preserve an exported Foundry Scene while binding marked pins to note pages. */
+
+import { journalPageId, splitPages } from "./journals.mjs";
+
+const EMBEDDED = Object.freeze([
+    "drawings",
+    "tokens",
+    "lights",
+    "notes",
+    "sounds",
+    "tiles",
+    "walls",
+    "regions",
+    "levels",
+]);
+
+/** Parse the deliberately small path syntax used inside a Scene fixup. */
+function fixupSegments(path) {
+    if (typeof path !== "string" || !path.startsWith(".")) {
+        throw new Error("a Scene fixup path must start with `.`");
+    }
+    const segments = [];
+    let at = 0;
+    while (at < path.length) {
+        const rest = path.slice(at);
+        const property = /^\.([A-Za-z_$][A-Za-z0-9_$]*)/.exec(rest);
+        if (property) {
+            segments.push({ kind: "property", key: property[1] });
+            at += property[0].length;
+            continue;
+        }
+        const bareId = /^\[([A-Za-z0-9]{16})\]/.exec(rest);
+        if (bareId) {
+            segments.push({ kind: "id", key: bareId[1] });
+            at += bareId[0].length;
+            continue;
+        }
+        const byId = /^\[_id=(?:"([A-Za-z0-9]{16})"|'([A-Za-z0-9]{16})'|([A-Za-z0-9]{16}))\]/.exec(
+            rest,
+        );
+        if (byId) {
+            segments.push({ kind: "id", key: byId[1] ?? byId[2] ?? byId[3] });
+            at += byId[0].length;
+            continue;
+        }
+        const index = /^\[(\d+)\]/.exec(rest);
+        if (index) {
+            segments.push({ kind: "index", key: Number(index[1]) });
+            at += index[0].length;
+            continue;
+        }
+        throw new Error(`invalid Scene fixup path "${path}" at "${rest}"`);
+    }
+    return segments;
+}
+
+/** Find the existing field a fixup addresses, without creating paths. */
+function fixupTarget(scene, path) {
+    const segments = fixupSegments(path);
+    let current = scene;
+    for (const segment of segments.slice(0, -1)) {
+        if (segment.kind === "property") {
+            if (!current || typeof current !== "object" || !Object.hasOwn(current, segment.key)) {
+                throw new Error(`Scene fixup path "${path}" has no property "${segment.key}"`);
+            }
+            current = current[segment.key];
+        } else if (segment.kind === "index") {
+            if (!Array.isArray(current) || segment.key >= current.length) {
+                throw new Error(`Scene fixup path "${path}" has no array index ${segment.key}`);
+            }
+            current = current[segment.key];
+        } else {
+            if (!Array.isArray(current)) {
+                throw new Error(`Scene fixup path "${path}" needs an array for _id selection`);
+            }
+            const matches = current.filter((value) => value?._id === segment.key);
+            if (matches.length !== 1) {
+                throw new Error(`Scene fixup path "${path}" matches ${matches.length} documents`);
+            }
+            current = matches[0];
+        }
+    }
+    const last = segments.at(-1);
+    if (
+        last?.kind !== "property" ||
+        !current ||
+        typeof current !== "object" ||
+        !Object.hasOwn(current, last.key)
+    ) {
+        throw new Error(`Scene fixup path "${path}" must end at an existing property`);
+    }
+    return { parent: current, key: last.key };
+}
+
+/** Apply author-declared asset address replacements to an exported Scene. */
+function applyFixups(scene, fixups, resolveAddress) {
+    if (fixups === undefined) return;
+    if (!Array.isArray(fixups)) throw new Error("`data.fixup` must be an array");
+    for (const [index, fixup] of fixups.entries()) {
+        if (
+            !fixup ||
+            typeof fixup !== "object" ||
+            Array.isArray(fixup) ||
+            fixup.type !== "address" ||
+            typeof fixup.value !== "string" ||
+            !fixup.value
+        ) {
+            throw new Error(
+                `data.fixup[${index}] needs path, type: address, and an asset address value`,
+            );
+        }
+        const { parent, key } = fixupTarget(scene, fixup.path);
+        if (typeof parent[key] !== "string" && parent[key] !== null) {
+            throw new Error(`Scene fixup path "${fixup.path}" must name a string asset field`);
+        }
+        if (typeof resolveAddress !== "function") {
+            throw new Error("Scene address fixups need an asset resolver");
+        }
+        const resolved = resolveAddress(fixup.value);
+        if (typeof resolved !== "string" || !resolved) {
+            throw new Error(`Scene fixup address "${fixup.value}" does not resolve to an asset`);
+        }
+        parent[key] = resolved;
+    }
+}
+
+/** Add a compendium key to one exported embedded document. */
+function keyDocument(doc, collection, parentIds, sceneId) {
+    if (!doc || typeof doc !== "object" || Array.isArray(doc)) {
+        throw new Error(`data.scene.${collection} contains a non-document value`);
+    }
+    if (!/^[A-Za-z0-9]{16}$/.test(doc._id ?? "")) {
+        throw new Error(`data.scene.${collection} needs a 16-character _id on every document`);
+    }
+    doc._key = `!scenes.${collection}!${[sceneId, ...parentIds, doc._id].join(".")}`;
+}
+
+/**
+ * Compile a Foundry Scene export into a pack document.
+ *
+ * Only the note-derived Scene ID, compendium metadata, and pins marked
+ * `#anchor` change. Every other authored Scene field passes through.
+ *
+ * @param {object} fm - The map note's frontmatter.
+ * @param {string} markdown - Its converted Markdown body.
+ * @param {object} [opts] - Pack metadata, derived JournalEntry ID, and asset resolver.
+ * @returns {object} The keyed Scene document.
+ */
+export function buildExportedScene(fm, markdown, { journalEntryId, stats, resolveAddress } = {}) {
+    if (!["battlemap", "localmap"].includes(fm.subType)) {
+        throw new Error("`data.scene` is for battlemap and localmap notes");
+    }
+    const source = fm.data?.scene;
+    if (!source || typeof source !== "object" || Array.isArray(source)) {
+        throw new Error("a map note needs a Foundry Scene object at `data.scene`");
+    }
+    if (!/^[A-Za-z0-9]{16}$/.test(fm.id ?? "")) {
+        throw new Error("a map note needs a derived 16-character Scene ID");
+    }
+    const scene = structuredClone(source);
+    applyFixups(scene, fm.data?.fixup, resolveAddress);
+    if (
+        !(Number.isInteger(scene.width) && scene.width > 0) ||
+        !(Number.isInteger(scene.height) && scene.height > 0)
+    ) {
+        throw new Error("`data.scene` needs positive whole-number width and height");
+    }
+    if (!Array.isArray(scene.levels) || scene.levels.length === 0) {
+        throw new Error("`data.scene.levels` needs at least one Level");
+    }
+    scene._id = fm.id;
+    scene._key = `!scenes!${fm.id}`;
+    if (stats) scene._stats = stats;
+
+    for (const collection of EMBEDDED) {
+        const docs = scene[collection];
+        if (docs === undefined) continue;
+        if (!Array.isArray(docs)) {
+            throw new Error(`data.scene.${collection} must be an array`);
+        }
+        const ids = new Set();
+        for (const doc of docs) {
+            keyDocument(doc, collection, [], fm.id);
+            if (ids.has(doc._id))
+                throw new Error(`data.scene.${collection} repeats _id ${doc._id}`);
+            ids.add(doc._id);
+            if (collection !== "regions" || doc.behaviors === undefined) continue;
+            if (!Array.isArray(doc.behaviors)) {
+                throw new Error("data.scene.regions.behaviors must be an array");
+            }
+            const behaviorIds = new Set();
+            for (const behavior of doc.behaviors) {
+                keyDocument(behavior, "regions.behaviors", [doc._id], fm.id);
+                if (behaviorIds.has(behavior._id)) {
+                    throw new Error(`data.scene.regions.behaviors repeats _id ${behavior._id}`);
+                }
+                behaviorIds.add(behavior._id);
+            }
+        }
+    }
+    if (scene.initialLevel && !scene.levels.some((level) => level._id === scene.initialLevel)) {
+        throw new Error(`data.scene.initialLevel "${scene.initialLevel}" names no Level`);
+    }
+
+    const pages = new Map();
+    for (const page of splitPages(markdown, fm.name?.full ?? scene.name)) {
+        if (!page.anchorSlug) continue;
+        if (pages.has(page.anchorSlug)) {
+            throw new Error(`the map note repeats anchor "${page.anchorSlug}"`);
+        }
+        pages.set(page.anchorSlug, page);
+    }
+    for (const pin of scene.notes ?? []) {
+        const match = /^#([A-Za-z0-9][A-Za-z0-9_-]*)$/.exec(String(pin.text ?? ""));
+        if (!match) continue;
+        const page = pages.get(match[1]);
+        if (!page) throw new Error(`Scene pin "${pin.text}" names no heading anchor in this note`);
+        if (!journalEntryId) {
+            throw new Error(`Scene pin "${pin.text}" needs a JournalEntry from this note`);
+        }
+        pin.entryId = journalEntryId;
+        pin.pageId = journalPageId(journalEntryId, page);
+        pin.text = page.name;
+    }
+    return scene;
+}

package/engine/generate.mjs

@@ -584,6 +584,7 @@ async function generatePack(
         // for the same reason `itemsSourceDirs` is, and scoped to this
         // pack's system so a bundle holds the catalogue it is compiled for.
         bundleSourceDirs: bundleSourceJsonDirs(config, system ?? null),
+        config,
         folderResolver: resolver,
         // One answer to "which files are the corpus?", from the configuration
         // this build resolved rather than from the working directory.

package/engine/ids.mjs

@@ -62,7 +62,7 @@ export const MAP_TYPES = Object.freeze(new Set(["map"]));
  *
  * @type {readonly string[]}
  */
-export const MAP_SUBTYPES = Object.freeze(["battlemap", "localmap", "regionalmap"]);
+export const MAP_SUBTYPES = Object.freeze(["battlemap", "localmap", "regionalmap", "totm"]);
 
 /**
  * Content types whose whole document **is** a JournalEntry.

package/engine/index.mjs

@@ -130,9 +130,15 @@ export * as calendars from "./calendars.mjs";
 /** A note's dates: one authored string, one grammar, one record shape. */
 export * as noteDates from "./note-dates.mjs";
 
+/** Era markers resolved from calendar notes in a corpus. */
+export * as reckoningMarkers from "./reckoning-markers.mjs";
+
 /** Calendars as notes: what one may declare, and the definition emitted from it. */
 export * as calendarNotes from "./calendar-notes.mjs";
 
+/** Compiled calendar definitions and import files from the content index. */
+export * as calendarArtifacts from "./calendar-artifacts.mjs";
+
 /** A being's `age`, absent beside a dated `born`: the age the date computes to. */
 export * as beingAge from "./being-age.mjs";
 

package/engine/infobox.mjs

@@ -575,6 +575,7 @@ function structuredRows(field, raw, resolve, label, fm) {
     }
     if (isMapping(raw) && !isAddressTuple(raw)) {
         const groups = new Map();
+        const seen = new Set();
         for (const [target, relation] of Object.entries(raw)) {
             if (!hasValue(target) || !hasValue(relation) || isMapping(relation)) continue;
             const term = String(relation);
@@ -591,6 +592,9 @@ function structuredRows(field, raw, resolve, label, fm) {
                 );
                 if (address.reason || (field.accepts && !field.accepts.includes(address.type)))
                     continue;
+                const canonical = renderAddress(address);
+                if (seen.has(canonical)) continue;
+                seen.add(canonical);
             }
             const links = groups.get(term) ?? [];
             links.push(linkValue(target, resolve, { type: field.ref }));

package/engine/itinerary-scenes.mjs

@@ -0,0 +1,170 @@
+/*
+ * 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 { 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 { makeId } from "./ids.mjs";
+import { stripAdventureKeys } from "./bundle-notes.mjs";
+
+/** The PNG's dimensions, from its fixed header. */
+function pngDimensions(file) {
+    const bytes = fs.readFileSync(file);
+    if (bytes.toString("hex", 0, 8) !== "89504e470d0a1a0a") {
+        throw new Error(`${file} is not a PNG`);
+    }
+    return [bytes.readUInt32BE(16), bytes.readUInt32BE(20)];
+}
+
+/** 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 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,
+        config.packageBuild.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 [width, height] = pngDimensions(png);
+        const positions = pinPositions(fs.readFileSync(plain, "utf8"), width, height);
+        const sceneId = makeId("itinerary-scene", `${config.contentPackage}:${centre}`);
+        const src = `${config.packageKind}/${config.foundryPackage.id}/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 };
+}

package/engine/map-build.mjs

@@ -29,10 +29,7 @@
  * - **`travel`** — the whole route graph, `travel.svg`.
  *
  * Every rendering is written beside the `.dot` it was drawn from, and the
- * `.dot` is written first: with GraphViz absent the command either stops with
- * an error naming what to install, or — where the caller asked it to — writes
- * the `.dot` files, returns one warning, and skips the rendering, which is
- * what a site build asking for maps does rather than fail.
+ * `.dot` is written first.
  *
  * A build never mutates its inputs: nothing here reads a note except to
  * locate a finding, and everything lands under the output directory.
@@ -44,7 +41,7 @@ import fs from "node:fs";
 import path from "node:path";
 
 import { fromDot, travelDot, treeDot } from "./map-dot.mjs";
-import { findGraphviz, graphvizMissingMessage, renderDot } from "./map-graphviz.mjs";
+import { renderDot } from "./map-graphviz.mjs";
 import { CHART_HORIZON_DAYS, layoutChart, layoutFrom, travelGraph } from "./map-layout.mjs";
 import { TRAVEL_DAYS } from "./place-relations.mjs";
 import { analyzeContainment, containmentFindings } from "./map-places.mjs";
@@ -106,17 +103,11 @@ export function relatedPlaces(places) {
  * @param {number} [opts.ranksep] - The tree's `ranksep`, inches.
  * @param {number} [opts.scale=1] - Multiplies every node's size and font.
  * @param {boolean} [opts.polities=true] - Whether the tree draws polities.
- * @param {(engine: string) => string|undefined} [opts.locate] - How a GraphViz
- *   engine's binary is found; the real lookup by default.
- * @param {boolean} [opts.requireGraphviz=true] - Whether a missing engine is
- *   an error. False, the `.dot` files are written, the renderings skipped,
- *   and one warning returned.
  * @returns {{written: string[], findings: Array<{file: string, line?: number,
- *   column?: number, severity: "error"|"warning", message: string}>,
- *   skipped: boolean}} What was written, what was found, and whether the
- *   rendering was skipped for want of GraphViz.
+ *   column?: number, severity: "error"|"warning", message: string}>}} What was
+ *   written and what was found.
  * @throws {Error} When no mode is asked for, a named place is not one, the
- *   horizon is not a marker of the scale, or GraphViz is required and absent.
+ *   horizon is not a marker of the scale.
  */
 export function buildMaps({
     world,
@@ -133,8 +124,6 @@ export function buildMaps({
     ranksep,
     scale = 1,
     polities = true,
-    locate = findGraphviz,
-    requireGraphviz = true,
 }) {
     if (!tree && from.length === 0 && chart.length === 0 && !travel) {
         throw new Error(
@@ -148,39 +137,15 @@ export function buildMaps({
     }
     const { places } = world;
 
-    // Every binary this run needs, found once and before anything is drawn,
-    // so a missing one is reported before a directory is touched.
-    const engines = new Set();
-    if (tree) engines.add(engine);
-    if (from.length || chart.length || travel) engines.add("neato");
-    /** @type {Map<string, string>} */
-    const binaries = new Map();
     const findings = [];
-    let skipped = false;
-    for (const name of engines) {
-        const binary = locate(name);
-        if (binary) binaries.set(name, binary);
-        else if (requireGraphviz) throw new Error(graphvizMissingMessage(name));
-        else if (!skipped) {
-            skipped = true;
-            findings.push({
-                file: outDir,
-                severity: "warning",
-                message: `${graphvizMissingMessage(name)}; the .dot files are written and the renderings skipped`,
-            });
-        }
-    }
-
     fs.mkdirSync(outDir, { recursive: true });
     const written = [];
-    const emit = (name, dot, engineName, args = []) => {
+    const emit = (name, dot, engineName, nop) => {
         const dotPath = path.join(outDir, `${name}.dot`);
         fs.writeFileSync(dotPath, dot);
         written.push(dotPath);
-        const binary = binaries.get(engineName);
-        if (!binary) return;
         const svgPath = path.join(outDir, `${name}.svg`);
-        const { warnings } = renderDot(dotPath, svgPath, { binary, args });
+        const { warnings } = renderDot(dotPath, svgPath, { engine: engineName, nop });
         written.push(svgPath);
         if (warnings) {
             findings.push({ file: dotPath, severity: "warning", message: warnings });
@@ -226,7 +191,7 @@ export function buildMaps({
                 message: `place "${place}" names "${to}" in a border or a route, and no place declares that shortcode; the map centred on "${centre}" leaves it out`,
             });
         }
-        emit(`from-${centre}`, fromDot(layout, places, { scale }), "neato", ["-n2"]);
+        emit(`from-${centre}`, fromDot(layout, places, { scale }), "neato", 2);
     }
 
     const viewpoints = chart.includes(FROM_ALL) ? relatedPlaces(places) : chart;
@@ -239,7 +204,7 @@ export function buildMaps({
                 message: `place "${place}" names "${to}" in a border or a route, and no place declares that shortcode; the chart centred on "${centre}" leaves it out`,
             });
         }
-        emit(`chart-${centre}`, fromDot(layout, places, { scale }), "neato", ["-n2"]);
+        emit(`chart-${centre}`, fromDot(layout, places, { scale }), "neato", 2);
     }
 
     if (travel) {
@@ -254,7 +219,7 @@ export function buildMaps({
         emit("travel", travelDot(graph, places, { scale }), "neato");
     }
 
-    return { written, findings, skipped };
+    return { written, findings };
 }
 
 /**

package/engine/map-dot.mjs

@@ -330,7 +330,7 @@ function emitLegend(lines, scale) {
  */
 function placeAttrs(place, analysis, scale) {
     const onCycle = analysis.cycleNodes.has(place.shortcode);
-    const noParent = place.parents.length === 0 && place.shortcode !== analysis.world;
+    const noParent = place.parents.length === 0 && !analysis.worlds.includes(place.shortcode);
     return styleAttrs(place.subType ?? "settlement", {
         scale,
         label: place.name,
@@ -399,7 +399,10 @@ export function treeDot({
     scale = 1,
     drawPolities = true,
 }) {
-    const world = analysis.world;
+    const world =
+        root === undefined ? analysis.world
+        : analysis.worlds.includes(root) ? root
+        : places.get(root)?.parents.find((parent) => analysis.worlds.includes(parent));
     let included;
     let scopeLabel;
     let worldIsContext = false;
@@ -439,7 +442,7 @@ export function treeDot({
     lines.push('  edge [fontname="Helvetica", fontsize=8];');
     const heading =
         title ??
-        `${scopeLabel ?? (world ? places.get(world)?.name : "The world")} — containment tree`;
+        `${scopeLabel ?? (world ? places.get(world)?.name : "The worlds")} — containment tree`;
     lines.push(`  label=${dotString(heading)};`);
     lines.push('  labelloc=t; fontsize=18; fontname="Helvetica-Bold";');
     lines.push("");