@heroiclands/package-build 22.4.6 → 22.5.0

package/engine/content-tables.mjs

@@ -1107,7 +1107,8 @@ function whereText(query) {
  *   each came from, so a diagnostic about the expanded body can name an
  *   authored position. An `errors` entry carries the 0-based line of the
  *   directive that failed, for the same reason. `warnings` holds one entry per
- *   `dataview` directive the body still authors.
+ *   `dataview` directive the body still authors, and one per `sql` directive
+ *   that leaves out stubs it would otherwise list.
  */
 export function expandContentTables(
     markdown,
@@ -1176,7 +1177,17 @@ export function expandContentTables(
                     "`sqlTables`, so the query could not be run"
                 : prepared.reason ? prepared.reason
                 : prepared.rows === 0 && !prepared.allowEmpty ?
-                    "sql query selects no notes — write ```sql allow-empty if " + "that is intended"
+                    // A table that lost every row to the stub rule says so.
+                    // "selects no notes" is true and useless here: the notes
+                    // are there, and the fence is reading the relation that
+                    // leaves them out.
+                    prepared.stubsExcluded > 0 ?
+                        `sql query selects no notes — ${prepared.stubsExcluded} stub(s) ` +
+                        "match it, and `FROM notes` leaves stubs out; select " +
+                        "`FROM entries` to list them beside the written notes, or " +
+                        "write ```sql allow-empty if the empty table is intended"
+                    :   "sql query selects no notes — write ```sql allow-empty if " +
+                        "that is intended"
                 :   undefined;
             if (failure) {
                 errors.push({
@@ -1190,6 +1201,22 @@ export function expandContentTables(
                 i = close;
                 continue;
             }
+            // A table selecting `FROM notes` that would gain rows from
+            // `FROM entries` has not adopted stubs. It is not wrong — which
+            // tables list the unwritten is the author's decision, and it is a
+            // one-word edit — so this is a warning at the fence rather than a
+            // failure, and the count is what makes it worth reading.
+            if (prepared.stubsExcluded > 0) {
+                warnings.push({
+                    source,
+                    line: i,
+                    column: indent.length + 1,
+                    reason:
+                        `this table selects \`FROM notes\`, which leaves out stubs; ` +
+                        `${prepared.stubsExcluded} stub(s) match it — select ` +
+                        `\`FROM entries\` to list them beside the written notes`,
+                });
+            }
             if (out.length > 0 && out[out.length - 1].trim() !== "") emit("", i, true);
             for (const row of prepared.markdown.split("\n")) emit(`${indent}${row}`, i, true);
             if (close + 1 < lines.length && lines[close + 1].trim() !== "") emit("", i, true);

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);

package/engine/holdings.mjs

@@ -0,0 +1,416 @@
+/*
+ * This file is part of the Song of Heroic Lands (SoHL) system for Foundry VTT.
+ * Copyright (c) 2024-2026 Tom Rodriguez ("Toasty") — <toasty@heroiclands.org>
+ *
+ * This work is licensed under the GNU General Public License v3.0 (GPLv3).
+ * You may copy, modify, and distribute it under the terms of that license.
+ *
+ * For full terms, see the LICENSE.md file in the project root or visit:
+ * https://www.gnu.org/licenses/gpl-3.0.html
+ *
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+
+/**
+ * What lies within a place, who holds it, and what an affiliation holds.
+ *
+ * Two keys the notes already carry answer all three. A place's `data.parents`
+ * is geography — the places it sits within — and an affiliation's
+ * `data.domains` is tenure — the places it holds. Read across the whole
+ * corpus and inverted, they give each page the lists a reader wants:
+ * `contains` and `held_by` on a place, `holdings` on an affiliation, each
+ * shaped like an entry of `related` and absent where empty.
+ *
+ * **`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 reachable from the region's `contains`, and
+ * repeating them in `holdings` would make every list say the same thing at
+ * every level. Tenure below a lord runs through `affiliation.parents` — a
+ * house of its earl, an earl of the crown — and geography through
+ * `place.parents`, 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.
+ *
+ * **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 place's tenure is checked.** A settlement, a site or a structure that no
+ * affiliation's `domains` names is land nobody holds — a gap in tenure the
+ * lint reports as a warning at the note's `type:` line. A region is held
+ * through its polity's `domains` and a feature by nobody, so both are exempt.
+ *
+ * @module
+ */
+
+import { positionInFrontmatter } from "./diagnostics.mjs";
+
+/**
+ * The keys this module writes, and which a note cannot author: `contains`
+ * and `held_by` on a place, `holdings` on an affiliation.
+ *
+ * @type {readonly string[]}
+ */
+export const HOLDINGS_KEYS = Object.freeze(["contains", "held_by", "holdings"]);
+
+/**
+ * The place subTypes tenure is checked on. A region is held through its
+ * polity's `domains`, a world by nobody, a feature by nobody — a river has no
+ * lord — so the rest are the kinds of place a body holds directly.
+ *
+ * @type {readonly string[]}
+ */
+export const HELD_SUBTYPES = Object.freeze(["settlement", "site", "structure"]);
+
+/**
+ * One entry of a holdings list — a page a reader is pointed at.
+ *
+ * @typedef {object} HoldingsEntry
+ * @property {string} title   The page's published title.
+ * @property {string} [url]   `<base><slug>/` — the page's address as every
+ *                            href this build renders composes it. **Absent
+ *                            for a stub**, which has no page: an entry with no
+ *                            `url` renders as plain text.
+ * @property {string} type    The note's `type` — `place` or `affiliation`.
+ * @property {string} [subType] The note's `subType`, where it declares one.
+ */
+
+/**
+ * One place or affiliation, as the derivation reads it — a local page or a
+ * fetched index entry through one shape.
+ *
+ * @typedef {object} HoldingsNode
+ * @property {string} shortcode Lower case.
+ * @property {"place"|"affiliation"} type
+ * @property {string} [subType]
+ * @property {string} title     The page's published title.
+ * @property {string} [url]     The page's URL; absent where the package
+ *                              publishes no page for it.
+ * @property {string[]} parents What a place sits within, as written.
+ * @property {string[]} domains What an affiliation holds, as written.
+ */
+
+/**
+ * The lists one page carries. Every key is optional, and a key present holds
+ * at least one entry.
+ *
+ * @typedef {object} Holdings
+ * @property {HoldingsEntry[]} [contains] Places whose `parents` name this one.
+ * @property {HoldingsEntry[]} [held_by]  Affiliations whose `domains` name this one.
+ * @property {HoldingsEntry[]} [holdings] Places this affiliation's `domains` name.
+ */
+
+/**
+ * The shortcode a `parents` or `domains` entry names, lower case.
+ *
+ * An entry is written as a bare shortcode, as an address, or as a wikilink
+ * carrying either; the shortcode is the last segment of the address in every
+ * case, because a segment carries no separator.
+ *
+ * @param {unknown} value - One entry.
+ * @returns {string} Its shortcode, or `""` for an entry that names nothing.
+ */
+function namedShortcode(value) {
+    const text = String(value ?? "")
+        .trim()
+        .replace(/^\[\[/, "")
+        .replace(/\]\]$/, "")
+        .split("|")[0]
+        .split("#")[0]
+        .trim();
+    return text.split("-").pop()?.toLowerCase() ?? "";
+}
+
+/**
+ * A `parents` or `domains` value as the shortcodes it names, in order,
+ * empties dropped and repeats collapsed.
+ *
+ * @param {unknown} value - The authored value — a list, or a lone entry.
+ * @returns {string[]} The shortcodes.
+ */
+export function shortcodesOf(value) {
+    const list =
+        Array.isArray(value) ? value
+        : value ? [value]
+        : [];
+    return [...new Set(list.map(namedShortcode).filter(Boolean))];
+}
+
+/**
+ * A stable order for `contains` and `holdings`: by subType, then title. An
+ * entry with no subType sorts first.
+ *
+ * @param {HoldingsEntry} a
+ * @param {HoldingsEntry} b
+ * @returns {number}
+ */
+function bySubTypeThenTitle(a, b) {
+    return (
+        (a.subType ?? "").localeCompare(b.subType ?? "", "en") ||
+        a.title.localeCompare(b.title, "en")
+    );
+}
+
+/**
+ * A stable order for `held_by`: by title.
+ *
+ * @param {HoldingsEntry} a
+ * @param {HoldingsEntry} b
+ * @returns {number}
+ */
+function byTitle(a, b) {
+    return a.title.localeCompare(b.title, "en");
+}
+
+/**
+ * The entry a node is listed as.
+ *
+ * **`url` is absent for a node that publishes no page**, and the entry is
+ * emitted all the same. A stub is a place somebody has not written yet: it
+ * carries its facts, and Weyshott belongs in Aelwyth's `contains` whether or
+ * not anyone has written Weyshott's page. What it cannot have is a link, so
+ * the renderer prints the title as plain text — the same rule a table cell
+ * follows when its `_ref` is null, in a different renderer.
+ *
+ * @param {HoldingsNode} node - The node.
+ * @returns {HoldingsEntry} Its entry.
+ */
+function entryOf(node) {
+    return {
+        title: node.title,
+        ...(listed(node) ? { url: node.url } : {}),
+        type: node.type,
+        ...(node.subType === undefined ? {} : { subType: node.subType }),
+    };
+}
+
+/**
+ * Whether a node publishes a page.
+ *
+ * **A URL gates where a list is written, never whether a node may appear in
+ * someone else's list.** You cannot write a `contains` block on a page that
+ * does not exist, so this guards {@link holdingsPages}'s `on(url)` calls — and
+ * nothing else. Guarding the membership too is how a stub vanishes from every
+ * containment and tenure list in the corpus, silently, which is the one failure
+ * mode a diff cannot show.
+ *
+ * @param {HoldingsNode} node - The node.
+ * @returns {boolean} Whether it has a page to write a list on.
+ */
+function listed(node) {
+    return node.url !== undefined && node.url !== null && node.url !== "";
+}
+
+/**
+ * Read a local note into a node, or `null` for a note that takes no part.
+ *
+ * @param {object} fm - The note's frontmatter.
+ * @param {object} page - The page it publishes as.
+ * @param {string} page.title - Its published title.
+ * @param {string} page.url - Its URL.
+ * @returns {HoldingsNode|null} The node, or `null` for a note that is neither
+ *   a place nor an affiliation, or that declares no shortcode.
+ */
+export function holdingsNode(fm, { title, url }) {
+    const type = String(fm?.type ?? "");
+    if (type !== "place" && type !== "affiliation") return null;
+    const shortcode = String(fm?.shortcode ?? "").toLowerCase();
+    if (!shortcode) return null;
+    const data = fm.data && typeof fm.data === "object" && !Array.isArray(fm.data) ? fm.data : {};
+    return {
+        shortcode,
+        type,
+        subType: fm.subType == null ? undefined : String(fm.subType),
+        title,
+        url,
+        parents: type === "place" ? shortcodesOf(data.parents) : [],
+        domains: type === "affiliation" ? shortcodesOf(data.domains) : [],
+    };
+}
+
+/**
+ * Read a fetched index's places and affiliations as nodes.
+ *
+ * An entry carries what the producer's record stated — its name, `subType`,
+ * `parents` and `domains` — and its page URL where the package publishes one.
+ *
+ * @param {Map<string, object>|undefined} foreignIndex - As
+ *   {@link module:engine/metadata-index.loadForeignIndexes} returns it.
+ * @returns {HoldingsNode[]} The nodes, in index order.
+ */
+export function foreignHoldingsNodes(foreignIndex) {
+    const out = [];
+    if (!foreignIndex) return out;
+    for (const [canonical, entry] of foreignIndex) {
+        const type = String(entry?.type ?? "");
+        if (type !== "place" && type !== "affiliation") continue;
+        const shortcode = canonical.split("-").pop()?.toLowerCase() ?? "";
+        if (!shortcode) continue;
+        out.push({
+            shortcode,
+            type,
+            subType: entry.subType == null ? undefined : String(entry.subType),
+            title: String(entry.name ?? shortcode),
+            url: entry.url,
+            parents: type === "place" ? shortcodesOf(entry.parents) : [],
+            domains: type === "affiliation" ? shortcodesOf(entry.domains) : [],
+        });
+    }
+    return out;
+}
+
+/**
+ * Invert `parents` and `domains` into each page's lists.
+ *
+ * A shortcode is declared once per type: the first node declaring it wins,
+ * so local nodes handed in ahead of fetched ones shadow a dependency's, the
+ * way the link resolver answers. A node with no URL carries no lists of its
+ * own, since there is no page to write them on — and is still an entry on
+ * everybody else's, rendered as plain text. A name no node declares is
+ * dropped: a `parents` naming nowhere is the map's finding, a `domains`
+ * naming nowhere the reference check's.
+ *
+ * The result holds only pages with at least one entry on at least one list,
+ * and a page's block carries only the keys it has entries for — the theme's
+ * silent-disappear convention, kept at the source.
+ *
+ * @param {Iterable<HoldingsNode|null>} nodes - Every place and affiliation,
+ *   local first. `parents` and `domains` are read as written, so a node
+ *   built by hand may carry them as the note spells them.
+ * @returns {Map<string, Holdings>} URL → the page's lists, sorted.
+ */
+export function holdingsPages(nodes) {
+    /** @type {Map<string, HoldingsNode>} */
+    const places = new Map();
+    /** @type {Map<string, HoldingsNode>} */
+    const affiliations = new Map();
+    for (const node of nodes) {
+        if (!node) continue;
+        const by = node.type === "place" ? places : affiliations;
+        const shortcode = String(node.shortcode ?? "").toLowerCase();
+        if (!shortcode || by.has(shortcode)) continue;
+        // Read through the one reader, so a caller handing in what a note
+        // wrote — an address, a wikilink, a repeat — is read as `holdingsNode`
+        // reads it.
+        by.set(shortcode, {
+            ...node,
+            shortcode,
+            parents: shortcodesOf(node.parents),
+            domains: shortcodesOf(node.domains),
+        });
+    }
+
+    /** @type {Map<string, {contains: HoldingsEntry[], held_by: HoldingsEntry[], holdings: HoldingsEntry[]}>} */
+    const lists = new Map();
+    const on = (url) => {
+        let found = lists.get(url);
+        if (!found) {
+            found = { contains: [], held_by: [], holdings: [] };
+            lists.set(url, found);
+        }
+        return found;
+    };
+    // Every gate below is on the page a list is *written* on, never on the
+    // node the list names — see {@link listed}.
+    for (const child of places.values()) {
+        for (const shortcode of child.parents) {
+            const parent = places.get(shortcode);
+            if (!parent || !listed(parent) || parent === child) continue;
+            on(parent.url).contains.push(entryOf(child));
+        }
+    }
+
+    for (const holder of affiliations.values()) {
+        for (const shortcode of holder.domains) {
+            const held = places.get(shortcode);
+            if (!held) continue;
+            if (listed(holder)) on(holder.url).holdings.push(entryOf(held));
+            if (listed(held)) on(held.url).held_by.push(entryOf(holder));
+        }
+    }
+
+    const out = new Map();
+    for (const [url, { contains, held_by, holdings }] of lists) {
+        /** @type {Holdings} */
+        const block = {};
+        if (contains.length) block.contains = contains.sort(bySubTypeThenTitle);
+        if (held_by.length) block.held_by = held_by.sort(byTitle);
+        if (holdings.length) block.holdings = holdings.sort(bySubTypeThenTitle);
+        if (Object.keys(block).length) out.set(url, block);
+    }
+    return out;
+}
+
+/* --------------------------------------------------------------------- */
+/*  The lint                                                              */
+/* --------------------------------------------------------------------- */
+
+/**
+ * Every shortcode some affiliation's `domains` names, computed once per link
+ * index. The lint asks the question once per place note, and the answer is a
+ * fact about the whole corpus — local notes and every fetched entry — so it
+ * is read off the index the first time and kept beside it.
+ *
+ * @type {WeakMap<object, Set<string>>}
+ */
+const HELD = new WeakMap();
+
+/**
+ * The shortcodes every affiliation's `domains` names, across the link index.
+ *
+ * @param {object} index - The link index.
+ * @returns {Set<string>} The held shortcodes, lower case.
+ */
+function heldShortcodes(index) {
+    let held = HELD.get(index);
+    if (held) return held;
+    held = new Set();
+    for (const note of index.notes ?? []) {
+        if (String(note.type ?? note.fm?.type ?? "") !== "affiliation") continue;
+        const data = note.fm?.data;
+        const domains = data && typeof data === "object" ? data.domains : undefined;
+        for (const shortcode of shortcodesOf(domains)) held.add(shortcode);
+    }
+    for (const entry of index.foreign?.index?.values?.() ?? []) {
+        if (String(entry?.type ?? "") !== "affiliation") continue;
+        for (const shortcode of shortcodesOf(entry.domains)) held.add(shortcode);
+    }
+    HELD.set(index, held);
+    return held;
+}
+
+/**
+ * Check a place note's tenure: a settlement, a site or a structure that no
+ * affiliation's `domains` names is unheld land, reported as a warning at the
+ * note's `type:` line.
+ *
+ * Declared on the `place` vocabulary as its type-level check, so the lint
+ * runs it beside the field checks with the same index. Without an index the
+ * question cannot be asked and nothing is reported.
+ *
+ * @param {object} note - The note, as the link index hands it over.
+ * @param {object} [opts]
+ * @param {object} [opts.index] - The link index, holding every affiliation.
+ * @returns {object[]} Findings.
+ */
+export function checkHeld(note, { index } = {}) {
+    if (!index) return [];
+    const fm = note.fm ?? {};
+    if (String(fm.type ?? "") !== "place") return [];
+    const subType = String(fm.subType ?? "");
+    if (!HELD_SUBTYPES.includes(subType)) return [];
+    const shortcode = String(fm.shortcode ?? "").toLowerCase();
+    if (!shortcode) return [];
+    if (heldShortcodes(index).has(shortcode)) return [];
+    return [
+        {
+            file: note.file,
+            ...positionInFrontmatter(note.raw ?? "", "type", undefined, { topLevel: true }),
+            severity: "warning",
+            message:
+                `unheld land: no affiliation's \`domains\` names "${shortcode}", so nothing ` +
+                `says who holds this ${subType}; name it in the \`domains\` of the house, ` +
+                `order or polity that does`,
+        },
+    ];
+}

package/engine/index-records.mjs

@@ -168,6 +168,31 @@ export function isNoteRecord(record) {
     return !record?.documents && !isAssetRecord(record);
 }
 
+/**
+ * Whether a record is a **stub**: a note with an empty body.
+ *
+ * Asked of the **absent address**, not of a marker block, because the absent
+ * address is the whole signal. A note's body is not in the index — the index
+ * carries what is *about* a note — so there is nothing else to ask, and nothing
+ * else needs to be: an address is emitted if and only if the body is non-empty
+ * on a type an empty body suppresses (see
+ * {@link module:engine/note-state.isStubNote}).
+ *
+ * A stub keeps its file, its `id` and, where its type compiles one, its Foundry
+ * document. What the empty body suppresses is the **page**, and the address and
+ * the link target that go with it.
+ *
+ * Asked only of a note's own record. A documentation journal and an asset are
+ * documents rather than notes, and both are addressed whatever the note they
+ * belong to says.
+ *
+ * @param {Record<string, any>} record - An index record.
+ * @returns {boolean} True for a stub's record.
+ */
+export function isStub(record) {
+    return isNoteRecord(record) && !record?.address;
+}
+
 /**
  * The path a record names inside its package, whichever shape it is.
  *

package/engine/index.mjs

@@ -84,9 +84,22 @@ export * as noteSchemas from "./note-schemas.mjs";
 /** The closed frontmatter regions: the `data:` container and each type's `subType`. */
 export * as noteVocabulary from "./note-vocabulary.mjs";
 
+/** The three states of a note — stub, draft, full — and the empty body they rest on. */
+export * as noteState from "./note-state.mjs";
+
+/** Whether every empty body is a stub on purpose, and how finished a tree is. */
+export * as stubLint from "./stub-lint.mjs";
+
 /** What a place is next to and reachable from: the closed sets, and the checks. */
 export * as placeRelations from "./place-relations.mjs";
 
+/** What lies within a place, who holds it, and what an affiliation holds — the page lists, and the tenure check. */
+export * as holdings from "./holdings.mjs";
+export * as populations from "./populations.mjs";
+
+/** What trade a settlement supports: the six-step market scale, and the check that holds a value to it. */
+export * as marketClass from "./market-class.mjs";
+
 /** The places a map is drawn from, read from the content index, and what `parents` says about them. */
 export * as mapPlaces from "./map-places.mjs";
 
@@ -102,6 +115,9 @@ export * as mapGraphviz from "./map-graphviz.mjs";
 /** `content-build map`: the drawings, written under `build/map/`. */
 export * as mapBuild from "./map-build.mjs";
 
+/** The map from each place, drawn for the site and written into its page. */
+export * as siteMaps from "./site-maps.mjs";
+
 /** The closed registry of system ids, and the `none` that stands for no system. */
 export * as systems from "./systems.mjs";
 

package/engine/map-graphviz.mjs

@@ -89,9 +89,19 @@ export function findGraphviz(engine, { env = process.env, fallbacks = KNOWN_DIRE
     return undefined;
 }
 
+/**
+ * What installs GraphViz on the two platforms a contributor is likely to be
+ * on, as the clause every "not installed" message ends with.
+ *
+ * @type {string}
+ */
+export const GRAPHVIZ_INSTALL =
+    "install GraphViz (`brew install graphviz` on macOS, " +
+    "`apt-get install graphviz` on Debian or Ubuntu)";
+
 /**
  * What to say when an engine is not installed: the name, and what installs
- * it on the two platforms a contributor is likely to be on.
+ * it.
  *
  * @param {string} engine - The engine that was wanted.
  * @returns {string} The message.
@@ -99,8 +109,7 @@ export function findGraphviz(engine, { env = process.env, fallbacks = KNOWN_DIRE
 export function graphvizMissingMessage(engine) {
     return (
         `GraphViz's \`${engine}\` is not installed, and \`content-build map\` draws with it; ` +
-        `install GraphViz (\`brew install graphviz\` on macOS, ` +
-        `\`apt-get install graphviz\` on Debian or Ubuntu) and run the command again`
+        `${GRAPHVIZ_INSTALL} and run the command again`
     );
 }
 

package/engine/map-places.mjs

@@ -251,14 +251,44 @@ export function loadMapWorld({ config, contentBase, base, problems }) {
         skipDirectories: config.skipDirectories,
         problems,
     });
-    const world = placesFromRecords(records, { contentBase: tree, base });
-    world.config = config;
     const foreign = loadForeignIndexes(config, [config.contentPackage]);
-    addForeignPlaces(world, foreign.index);
+    const world = mapWorld({
+        records,
+        foreignIndex: foreign.index,
+        contentBase: tree,
+        base,
+        config,
+    });
     world.stale = foreign.stale;
     return world;
 }
 
+/**
+ * The world a map is drawn from, out of records and indexes a caller already
+ * holds: this package's places from its index records, and every
+ * dependency's from the fetched indexes. The site build reads its corpus and
+ * its foreign indexes once for every surface it publishes, and hands them
+ * here rather than walking the tree a second time.
+ *
+ * @param {object} opts
+ * @param {Array<Record<string, any>>} opts.records - Index records, as
+ *   {@link module:engine/content-index.indexRecordsFor} returns them.
+ * @param {Map<string, object>} opts.foreignIndex - The fetched indexes, as
+ *   {@link module:engine/metadata-index.loadForeignIndexes} returns `index`.
+ * @param {string} opts.contentBase - The content root the records were read from.
+ * @param {string} [opts.base] - The site base this package's pages are served
+ *   under. Absent, no local place carries a URL.
+ * @param {object} opts.config - The resolved configuration.
+ * @returns {MapWorld} The world, with nothing stale: the caller has already
+ *   judged its indexes usable.
+ */
+export function mapWorld({ records, foreignIndex, contentBase, base, config }) {
+    const world = placesFromRecords(records, { contentBase, base });
+    world.config = config;
+    addForeignPlaces(world, foreignIndex);
+    return world;
+}
+
 /* --------------------------------------------------------------------- */
 /*  Containment                                                           */
 /* --------------------------------------------------------------------- */