hoi4-agent-tools 4.4.0 → 4.5.0

package/dist/hoi4_agent_tools/map/tool-operations.js

@@ -6,7 +6,7 @@ import { autonomousResultArtifacts, } from '../core/transaction-execution.js';
 import { emptyServiceResult, ServiceError } from '../core/result.js';
 import { setInlineFilesScanned } from '../core/operation-result.js';
 import { PACKAGE_VERSION } from '../version.js';
-import { allocateMapIdentifiersAsync, } from './operations.js';
+import { allocateMapIdentifiersAsync, WORLD_OUTPUT_PATH_SAMPLE, } from './operations.js';
 import { borderQualityDiagnostics } from './border-quality.js';
 import { measureIndexBorderNaturalness, summarizeBorderQuality, } from './border-quality-input.js';
 import { buildMapCatalog, lookupMapCoordinate, searchMapCatalog } from './catalog.js';
@@ -301,6 +301,7 @@ export async function prepareMapRewrite(nudger, input, context) {
                 semanticDiff: compactSemantic.semantic,
                 semanticDiffCounts: compactSemantic.counts,
                 semanticDiffTruncated: compactSemantic.truncated,
+                ...worldOutputsData(planned.plan),
             }),
             filesScanned: planned.filesScanned,
             planBlockers: planned.plan.blockers
@@ -309,6 +310,44 @@ export async function prepareMapRewrite(nudger, input, context) {
         }),
     };
 }
+/** Counts and sorted samples of the managed outputs each generated world writes, retires and releases. */
+function worldOutputsData(plan) {
+    if (plan.worldOutputs === undefined)
+        return {};
+    const sample = (paths) => paths.slice(0, WORLD_OUTPUT_PATH_SAMPLE);
+    const realms = plan.worldOutputs.flatMap(({ operationId, realms: placed }) => placed === undefined
+        ? []
+        : [
+            {
+                operationId,
+                countries: placed.countries.slice(0, 100).map((country) => ({
+                    tag: country.tag,
+                    capitalState: country.capitalState,
+                    capitalProvince: country.capitalProvince,
+                    states: country.states.length,
+                    provinces: country.provinces,
+                    landShare: country.landShare,
+                    targetShare: country.targetShare,
+                })),
+                countryCount: placed.countries.length,
+                unownedStates: placed.unownedStates.slice(0, WORLD_OUTPUT_PATH_SAMPLE),
+                unownedStateCount: placed.unownedStates.length,
+            },
+        ]);
+    return {
+        ...(realms.length === 0 ? {} : { realms: realms.slice(0, 16) }),
+        outputs: plan.worldOutputs.slice(0, 16).map((world) => ({
+            operationId: world.operationId,
+            written: world.written.length,
+            retired: world.retired.length,
+            released: world.released.length,
+            retiredFiles: sample(world.retired),
+            releasedFiles: sample(world.released),
+            truncated: world.retired.length > WORLD_OUTPUT_PATH_SAMPLE ||
+                world.released.length > WORLD_OUTPUT_PATH_SAMPLE,
+        })),
+    };
+}
 export function completeMapRewrite(workspaceId, execution, recipe) {
     const parsed = mapRewriteRecipeSchema.parse(recipe);
     const transaction = execution.transaction;
@@ -492,6 +531,7 @@ export async function previewMapRewrite(nudger, input, context) {
         semanticDiffTruncated: compactSemantic.truncated,
         fileCount: planned.plan.changes.length,
         artifactCount: planned.artifacts.length,
+        ...worldOutputsData(planned.plan),
         ...(input.operations.some(({ kind }) => kind === 'create_world') &&
             generatedWorldOperationIds(planned.plan).size === 0
             ? {}

package/dist/hoi4_agent_tools/map/world-context.js

@@ -169,3 +169,26 @@ export function buildWorldContext(base) {
     }
     return context;
 }
+/** The tag file a generated world writes for the countries it creates. */
+export const WORLD_COUNTRY_TAG_FILE = 'common/country_tags/zz_world_countries.txt';
+/** Country tags the active sources declare, apart from those of a previously generated world. */
+export function countryTagCatalog(base) {
+    const declared = new Set();
+    const dynamic = new Set();
+    for (const file of base.activeFiles.all) {
+        const name = normalized(file.relativePath);
+        if (!/^common\/country_tags\/[^/]+\.txt$/u.test(name) || name === WORLD_COUNTRY_TAG_FILE)
+            continue;
+        const entries = assignments(documentFor(file).root);
+        const isDynamic = entries.some((entry) => entry.key.value === 'dynamic_tags' &&
+            entry.value.type === 'scalar' &&
+            entry.value.value === 'yes');
+        for (const entry of entries)
+            if (/^[A-Z][A-Z0-9]{2}$/u.test(entry.key.value) && entry.value.type === 'scalar')
+                (isDynamic ? dynamic : declared).add(entry.key.value);
+    }
+    return {
+        static: [...declared].sort(compareCodeUnits),
+        dynamic: [...dynamic].filter((tag) => !declared.has(tag)).sort(compareCodeUnits),
+    };
+}

package/dist/hoi4_agent_tools/map/world-outputs.js

@@ -1,7 +1,25 @@
 import path from 'node:path';
-import { reconcileManagedOutputs } from '../core/managed-outputs.js';
+import { planManagedOutputs } from '../core/managed-outputs.js';
 export const WORLD_OUTPUT_MANIFEST = '.hoi4-agent-world.json';
+/** Country outputs of a generated world: tags, country files, histories, units, flags, bookmark. */
+export function isWorldCountryOutput(relativePath) {
+    const dir = path.posix.dirname(relativePath), file = path.posix.basename(relativePath);
+    return ((['common/countries', 'history/countries'].includes(dir) &&
+        /^[A-Z][A-Z0-9]{2} - [^/]+\.txt$/u.test(file)) ||
+        (dir === 'history/units' && /^[A-Z][A-Z0-9]{2}_world\.txt$/u.test(file)) ||
+        (['gfx/flags', 'gfx/flags/medium', 'gfx/flags/small'].includes(dir) &&
+            /^[A-Z][A-Z0-9]{2}\.tga$/u.test(file)) ||
+        [
+            'common/countries/colors.txt',
+            'common/country_tags/zz_world_countries.txt',
+            'common/bookmarks/world.txt',
+        ].includes(relativePath));
+}
 export function reconcileWorldOutputs(sources, proposed, operationId, mapRoot, stateRoots, localisationRoots) {
+    return planWorldOutputs(sources, proposed, operationId, mapRoot, stateRoots, localisationRoots)
+        .changes;
+}
+export function planWorldOutputs(sources, proposed, operationId, mapRoot, stateRoots, localisationRoots, options = {}) {
     const mapFiles = new Set([
         'provinces.bmp',
         'definition.csv',
@@ -29,15 +47,8 @@ export function reconcileWorldOutputs(sources, proposed, operationId, mapRoot, s
             (dir === `${mapRoot}/terrain` && /^colormap_[a-z0-9_]+\.dds$/u.test(file)) ||
             (dir === `${mapRoot}/strategicregions` && /^\d+.*\.txt$/u.test(file)) ||
             (stateRoots.includes(dir) && /^\d+.*\.txt$/u.test(file)) ||
-            (['common/countries', 'history/countries'].includes(dir) &&
-                /^[A-Z][A-Z0-9]{2} - [^/]+\.txt$/u.test(file)) ||
-            (dir === 'history/units' && /^[A-Z][A-Z0-9]{2}_world\.txt$/u.test(file)) ||
-            (['gfx/flags', 'gfx/flags/medium', 'gfx/flags/small'].includes(dir) &&
-                /^[A-Z][A-Z0-9]{2}\.tga$/u.test(file)) ||
+            isWorldCountryOutput(name) ||
             [
-                'common/countries/colors.txt',
-                'common/country_tags/zz_world_countries.txt',
-                'common/bookmarks/world.txt',
                 'common/on_actions/world.txt',
                 'common/ai_areas/world.txt',
                 'common/ai_strategy_plans/world.txt',
@@ -45,11 +56,12 @@ export function reconcileWorldOutputs(sources, proposed, operationId, mapRoot, s
             localisationRoots.some((root) => name === `${root}/english/world_l_english.yml` ||
                 name === `${root}/replace/world_l_english.yml`));
     };
-    return reconcileManagedOutputs({
+    return planManagedOutputs({
         manifestPath: WORLD_OUTPUT_MANIFEST,
         sources,
         proposed,
         operationId,
         permitsPath,
+        ...(options.releaseCountryOutputs === true ? { releasable: isWorldCountryOutput } : {}),
     });
 }

package/dist/hoi4_agent_tools/map/world-realms.js

@@ -0,0 +1,152 @@
+/**
+ * Workspace-owned countries in a generated world (ADR 0069): realm points and polygons resolved to
+ * provinces, and the rule for land that no realm reached.
+ */
+import { ServiceError } from '../core/result.js';
+function inside(x, y, polygon) {
+    let result = false;
+    for (let index = 0, previous = polygon.length - 1; index < polygon.length; previous = index++) {
+        const a = polygon[index], b = polygon[previous];
+        if (a.y > y !== b.y > y && x < ((b.x - a.x) * (y - a.y)) / (b.y - a.y) + a.x)
+            result = !result;
+    }
+    return result;
+}
+/** Land provinces with more than half their pixels inside any of the polygons. */
+function coveredProvinces(polygons, raster) {
+    const counts = new Map();
+    const pixels = new Set();
+    for (const polygon of polygons) {
+        const xs = polygon.map(({ x }) => x), ys = polygon.map(({ y }) => y);
+        const left = Math.max(0, Math.floor(Math.min(...xs)));
+        const right = Math.min(raster.width - 1, Math.ceil(Math.max(...xs)));
+        const top = Math.max(0, Math.floor(Math.min(...ys)));
+        const bottom = Math.min(raster.height - 1, Math.ceil(Math.max(...ys)));
+        for (let y = top; y <= bottom; y += 1)
+            for (let x = left; x <= right; x += 1) {
+                const pixel = y * raster.width + x;
+                if (pixels.has(pixel) || !inside(x + 0.5, y + 0.5, polygon))
+                    continue;
+                pixels.add(pixel);
+                const province = raster.pixelProvince[pixel];
+                counts.set(province, (counts.get(province) ?? 0) + 1);
+            }
+    }
+    const covered = new Set();
+    for (const [province, count] of [...counts].sort((left, right) => left[0] - right[0]))
+        if (raster.isLand(province) && count * 2 > raster.provinceSize[province])
+            covered.add(province);
+    return covered;
+}
+function pointProvince(tag, role, point, raster) {
+    const x = Math.floor(point.x), y = Math.floor(point.y);
+    if (x < 0 || y < 0 || x >= raster.width || y >= raster.height)
+        throw new ServiceError('MAP_WORLD_REALM_POINT_OUTSIDE', `The ${role} of ${tag} lies outside the ${raster.width}x${raster.height} world`, { tag, role, point });
+    const province = raster.pixelProvince[y * raster.width + x];
+    if (!raster.isLand(province))
+        throw new ServiceError('MAP_WORLD_REALM_POINT_WATER', `The ${role} of ${tag} lies in water`, {
+            tag,
+            role,
+            point,
+        });
+    return province;
+}
+export function resolveRealmRules(realms, raster) {
+    const unowned = realms.unowned === undefined ? new Set() : coveredProvinces(realms.unowned, raster);
+    const excluded = realms.list.map((realm) => realm.exclude === undefined ? new Set() : coveredProvinces(realm.exclude, raster));
+    const forced = new Map();
+    const claimedBy = (province) => realms.list[forced.get(province)].tag;
+    const conflict = (tag, role, other, details) => new ServiceError('MAP_WORLD_REALM_POINT_CONFLICT', `The ${role} of ${tag} lies in land ${other}`, { tag, role, ...details });
+    const capitals = [];
+    // Points first, so a claim that covers another realm's point names that point.
+    for (const [index, realm] of realms.list.entries()) {
+        for (const [role, point] of [
+            ['capital', realm.capital],
+            ...(realm.seeds ?? []).map((seed) => ['seed', seed]),
+        ]) {
+            const province = pointProvince(realm.tag, role, point, raster);
+            if (unowned.has(province))
+                throw conflict(realm.tag, role, 'marked unowned', { point, province });
+            if (excluded[index].has(province))
+                throw conflict(realm.tag, role, 'its own exclusion covers', { point, province });
+            const holder = forced.get(province);
+            if (holder !== undefined && holder !== index)
+                throw conflict(realm.tag, role, `that a point of ${claimedBy(province)} names`, {
+                    point,
+                    province,
+                    otherTag: claimedBy(province),
+                });
+            forced.set(province, index);
+            if (role === 'capital')
+                capitals.push(province);
+        }
+    }
+    for (const [index, realm] of realms.list.entries()) {
+        if (realm.claim === undefined)
+            continue;
+        for (const province of coveredProvinces(realm.claim, raster)) {
+            const holder = forced.get(province);
+            if (unowned.has(province) || excluded[index].has(province))
+                throw new ServiceError('MAP_WORLD_REALM_CLAIM_OVERLAP', `A claim of ${realm.tag} covers land that is ${unowned.has(province) ? 'marked unowned' : 'in its own exclusion'}`, { tag: realm.tag, province });
+            if (holder !== undefined && holder !== index)
+                throw new ServiceError('MAP_WORLD_REALM_CLAIM_OVERLAP', `A claim of ${realm.tag} covers land that ${claimedBy(province)} claims or names`, { tag: realm.tag, otherTag: claimedBy(province), province });
+            forced.set(province, index);
+        }
+    }
+    return { capitals, forced, excluded, unowned };
+}
+/**
+ * Land growth did not reach: a landmass that a realm already holds goes to the nearest realm that
+ * may own it; a landmass without any realm follows the island rule.
+ */
+export function assignUnreachedRealmLand(input) {
+    const held = new Set();
+    for (const id of input.owner.keys())
+        held.add(input.part(id));
+    const distance = (a, b) => (a.x - b.x) ** 2 + (a.y - b.y) ** 2;
+    const nearest = (point, allowed) => {
+        let best = -1;
+        let bestDistance = Number.POSITIVE_INFINITY;
+        for (const [realm, capital] of input.capitals.entries()) {
+            if (!allowed(realm))
+                continue;
+            const next = distance(point, input.center(capital));
+            if (next < bestDistance) {
+                best = realm;
+                bestDistance = next;
+            }
+        }
+        return best;
+    };
+    const pending = input.landIds.filter((id) => !input.owner.has(id) && !input.unowned.has(id));
+    const partOwner = new Map();
+    if (input.islands === 'one-owner') {
+        const members = new Map();
+        for (const id of pending)
+            if (!held.has(input.part(id))) {
+                const list = members.get(input.part(id)) ?? [];
+                list.push(id);
+                members.set(input.part(id), list);
+            }
+        for (const [part, ids] of members) {
+            const mean = ids.reduce((sum, id) => ({ x: sum.x + input.center(id).x, y: sum.y + input.center(id).y }), { x: 0, y: 0 });
+            partOwner.set(part, nearest({ x: mean.x / ids.length, y: mean.y / ids.length }, () => true));
+        }
+    }
+    for (const id of pending) {
+        const allowed = (realm) => !input.excluded[realm].has(id);
+        const island = !held.has(input.part(id));
+        if (island && input.islands === 'unowned') {
+            input.unowned.add(id);
+            continue;
+        }
+        const preferred = island ? partOwner.get(input.part(id)) : undefined;
+        const realm = preferred !== undefined && preferred >= 0 && allowed(preferred)
+            ? preferred
+            : nearest(input.center(id), allowed);
+        if (realm < 0)
+            input.unowned.add(id);
+        else
+            input.owner.set(id, realm);
+    }
+}

package/dist/hoi4_agent_tools/map/world.js

@@ -19,6 +19,7 @@ import { ambientObjectText, applyEdgePolicy, assertFeaturesOutsideBand, edgeWate
 import { landDistanceField, lakeHeight, normalizeLakes, waterColourLevel } from './water.js';
 import { overlayGeographyLakes, rasterizeGeographyKind } from './relief/land.js';
 import { synthesizeTerrain } from './relief/terrain-synthesis.js';
+import { assignUnreachedRealmLand, resolveRealmRules } from './world-realms.js';
 // ---------------------------------------------------------------------------------------------
 // Deterministic randomness and noise
 export class Random {
@@ -763,7 +764,9 @@ export function generateWorld(spec, context, options = {}) {
     const countryCount = spec.countries.length;
     const interpretationWarnings = [];
     const referenceOwners = new Map();
-    if (reference?.inferredCountries.length === countryCount && countryCount > 1) {
+    if (spec.realms === undefined &&
+        reference?.inferredCountries.length === countryCount &&
+        countryCount > 1) {
         const indexes = new Map();
         const unresolved = [];
         for (const [index, country] of spec.countries.entries()) {
@@ -844,6 +847,17 @@ export function generateWorld(spec, context, options = {}) {
     });
     const capitals = [];
     const largest = [...landIds].sort((left, right) => provinces.size[right] - provinces.size[left] || left - right);
+    const realmRules = spec.realms === undefined
+        ? undefined
+        : resolveRealmRules(spec.realms, {
+            width,
+            height,
+            pixelProvince: provinces.pixel,
+            provinceSize: provinces.size,
+            isLand: (id) => provinces.kind[id] === LAND,
+        });
+    if (realmRules !== undefined)
+        capitals.push(...realmRules.capitals);
     while (capitals.length < countryCount) {
         const countryIndex = capitals.length;
         const regionCandidates = largest.filter((id) => referenceOwners.get(id) === countryIndex && !capitals.includes(id));
@@ -879,20 +893,26 @@ export function generateWorld(spec, context, options = {}) {
     }
     const shares = spec.countries.map((country) => Math.max(0.05, country.share ?? 1));
     const owned = new Array(countryCount).fill(0);
-    for (const [id, country] of referenceOwners) {
+    for (const [id, country] of realmRules?.forced ?? referenceOwners) {
         owner.set(id, country);
         owned[country] += provinces.size[id];
     }
+    const unownedLand = realmRules?.unowned ?? new Set();
+    const blockedFor = (index, id) => unownedLand.has(id) || realmRules?.excluded[index].has(id) === true;
     const frontiers = capitals.map((capital, index) => {
-        owner.set(capital, index);
-        if (!referenceOwners.has(capital))
+        if (!owner.has(capital))
             owned[index] += provinces.size[capital];
+        owner.set(capital, index);
+        if (realmRules !== undefined)
+            return [...owner]
+                .filter(([, country]) => country === index)
+                .flatMap(([id]) => [...provinces.neighbors[id]]);
         return [...provinces.neighbors[capital]];
     });
     for (;;) {
         let chosen = -1;
         for (let index = 0; index < countryCount; index += 1) {
-            frontiers[index] = frontiers[index].filter((id) => provinces.kind[id] === LAND && !owner.has(id));
+            frontiers[index] = frontiers[index].filter((id) => provinces.kind[id] === LAND && !owner.has(id) && !blockedFor(index, id));
             if (frontiers[index].length === 0)
                 continue;
             if (chosen < 0 || owned[index] / shares[index] < owned[chosen] / shares[chosen])
@@ -908,9 +928,21 @@ export function generateWorld(spec, context, options = {}) {
             if (!owner.has(neighbor))
                 frontier.push(neighbor);
     }
+    // Land no workspace country reached follows the island rule; the rest of the land is unowned.
+    if (realmRules !== undefined)
+        assignUnreachedRealmLand({
+            landIds,
+            owner,
+            unowned: unownedLand,
+            capitals,
+            excluded: realmRules.excluded,
+            islands: spec.realms?.islands ?? 'nearest',
+            part: (id) => landParts.get(id),
+            center,
+        });
     // Islands no country reached go to the nearest capital's country.
     for (const id of landIds)
-        if (!owner.has(id)) {
+        if (!owner.has(id) && !unownedLand.has(id)) {
             const c = center(id);
             let best = 0;
             for (const [index, capital] of capitals.entries())
@@ -946,7 +978,7 @@ export function generateWorld(spec, context, options = {}) {
     // States: within each region and country, clusters of about provincesPerState.
     const groups = new Map();
     for (const id of landIds) {
-        const key = `${regionOf.get(id)}:${owner.get(id)}`;
+        const key = `${regionOf.get(id)}:${owner.get(id) ?? -1}`;
         const list = groups.get(key) ?? [];
         list.push(id);
         groups.set(key, list);
@@ -970,7 +1002,7 @@ export function generateWorld(spec, context, options = {}) {
             const draft = {
                 id: states.length + 1,
                 provinces: sorted,
-                owner: spec.countries[countryIndex].tag,
+                ...(countryIndex < 0 ? {} : { owner: spec.countries[countryIndex].tag }),
                 region,
                 capital: sorted[0],
                 manpower: 0,
@@ -1031,7 +1063,7 @@ export function generateWorld(spec, context, options = {}) {
             }[terrain.get(id) ?? 'plains'] ?? 0.5;
             return sum + value * provinces.size[id];
         }, 0) / pixels;
-        const isCapital = countryCapitalState.get(state.owner) === state;
+        const isCapital = state.owner !== undefined && countryCapitalState.get(state.owner) === state;
         const development = Math.min(1, habitability * (0.5 + random.next()) * (isCapital ? 1.8 : 1));
         state.manpower = Math.max(1_000, Math.round((pixels * 180 * development) / 1_000) * 1_000);
         const categoryIndex = Math.max(0, Math.min(categories.length - 1, Math.round(development * 5.2 + (isCapital ? 1 : 0))));
@@ -1140,6 +1172,7 @@ export function generateWorld(spec, context, options = {}) {
     const files = [];
     const add = (relativePath, content, mediaType = 'text/plain') => files.push({ relativePath, content, mediaType });
     const countryNames = new Map(spec.countries.map(({ tag, name }) => [tag, name]));
+    const ownerName = (state) => state.owner === undefined ? 'Free Land' : (countryNames.get(state.owner) ?? state.owner);
     const map = context.mapRoot;
     // provinces.bmp
     const rgb = new Array(width * height);
@@ -1543,8 +1576,9 @@ export function generateWorld(spec, context, options = {}) {
                     `\tresources = {\n${resources.map(([resource, amount]) => `\t\t${resource} = ${amount}`).join('\n')}\n\t}`,
                 ]),
             '\thistory = {',
-            `\t\towner = ${state.owner}`,
-            `\t\tadd_core_of = ${state.owner}`,
+            ...(state.owner === undefined
+                ? []
+                : [`\t\towner = ${state.owner}`, `\t\tadd_core_of = ${state.owner}`]),
             ...[...state.victoryPoints].map(([id, value]) => `\t\tvictory_points = { ${provinceId(id)} ${value} }`),
             '\t\tbuildings = {',
             ...buildings,
@@ -1559,7 +1593,8 @@ export function generateWorld(spec, context, options = {}) {
     const countryLocalisation = [];
     const countryLines = [];
     const countryColors = [];
-    for (const [index, country] of spec.countries.entries()) {
+    // Workspace-owned countries keep their own tags, files, histories, flags and names.
+    for (const [index, country] of (spec.realms === undefined ? spec.countries : []).entries()) {
         const color = country.color ?? {
             r: 60 + random.int(170),
             g: 60 + random.int(170),
@@ -1658,10 +1693,12 @@ export function generateWorld(spec, context, options = {}) {
             add(`gfx/flags/${folder}${country.tag}.tga`, encodeTga(flagWidth, flagHeight, (_x, y) => y < flagHeight / 3 ? light : y < (flagHeight * 2) / 3 ? color : dark), 'image/x-tga');
         void index;
     }
-    add('common/country_tags/zz_world_countries.txt', text(`${countryLines.join('\n')}\n`));
-    add('common/countries/colors.txt', text(`${countryColors.join('\n')}\n`));
+    if (spec.realms === undefined) {
+        add('common/country_tags/zz_world_countries.txt', text(`${countryLines.join('\n')}\n`));
+        add('common/countries/colors.txt', text(`${countryColors.join('\n')}\n`));
+    }
     if (spec.startingScenario) {
-        for (const tag of context.inheritedCountryTags ?? [])
+        for (const tag of spec.realms === undefined ? (context.inheritedCountryTags ?? []) : [])
             if (!countryNames.has(tag))
                 add(`history/countries/${tag} - inactive world.txt`, text('# Inherited tag has no territory or active starting country in this world.\n'));
         add('common/on_actions/world.txt', text('# Old-world startup hooks are replaced for this generated map.\non_actions = { }\n'));
@@ -1675,34 +1712,53 @@ export function generateWorld(spec, context, options = {}) {
         states
             .filter((state) => state.owner === left.tag)
             .reduce((sum, state) => sum + state.manpower, 0) || (left.tag < right.tag ? -1 : 1));
-    const majors = ranked.slice(0, Math.min(7, ranked.length));
-    add('common/bookmarks/world.txt', text([
-        'bookmarks = {',
-        '\tbookmark = {',
-        '\t\tname = "WORLD_BOOKMARK_NAME"',
-        '\t\tdesc = "WORLD_BOOKMARK_DESC"',
-        `\t\tdate = ${spec.startDate}.12`,
-        '\t\tpicture = "GFX_select_date_1936"',
-        `\t\tdefault_country = "${majors[0].tag}"`,
-        '\t\tdefault = yes',
-        ...majors.map((country) => `\t\t"${country.tag}" = {\n\t\t\thistory = "${country.tag}_WORLD_DESC"\n\t\t\tideology = ${country.ideology ?? 'neutrality'}\n\t\t}`),
-        '\t\t"---" = {\n\t\t\thistory = "WORLD_OTHER_DESC"\n\t\t}',
-        '\t\teffect = {\n\t\t\trandomize_weather = 22345\n\t\t}',
-        '\t}',
-        '}',
-        '',
-    ].join('\n')));
+    const majors = spec.realms === undefined ? ranked.slice(0, Math.min(7, ranked.length)) : [];
+    if (spec.realms === undefined)
+        add('common/bookmarks/world.txt', text([
+            'bookmarks = {',
+            '\tbookmark = {',
+            '\t\tname = "WORLD_BOOKMARK_NAME"',
+            '\t\tdesc = "WORLD_BOOKMARK_DESC"',
+            `\t\tdate = ${spec.startDate}.12`,
+            '\t\tpicture = "GFX_select_date_1936"',
+            `\t\tdefault_country = "${majors[0].tag}"`,
+            '\t\tdefault = yes',
+            ...majors.map((country) => `\t\t"${country.tag}" = {\n\t\t\thistory = "${country.tag}_WORLD_DESC"\n\t\t\tideology = ${country.ideology ?? 'neutrality'}\n\t\t}`),
+            '\t\t"---" = {\n\t\t\thistory = "WORLD_OTHER_DESC"\n\t\t}',
+            '\t\teffect = {\n\t\t\trandomize_weather = 22345\n\t\t}',
+            '\t}',
+            '}',
+            '',
+        ].join('\n')));
+    const realmSummary = () => {
+        const landPixels = landIds.reduce((sum, id) => sum + provinces.size[id], 0);
+        const weights = spec.countries.reduce((sum, country) => sum + (country.share ?? 1), 0);
+        return {
+            countries: spec.countries.map((country, index) => {
+                const ownedStates = states.filter((state) => state.owner === country.tag);
+                const pixels = ownedStates.reduce((sum, state) => sum + state.provinces.reduce((inner, id) => inner + provinces.size[id], 0), 0);
+                return {
+                    tag: country.tag,
+                    capitalState: countryCapitalState.get(country.tag).id,
+                    capitalProvince: provinceId(capitals[index]),
+                    states: ownedStates.map(({ id }) => id),
+                    provinces: ownedStates.reduce((sum, state) => sum + state.provinces.length, 0),
+                    landShare: Math.round((pixels / landPixels) * 10_000) / 10_000,
+                    targetShare: Math.round(((country.share ?? 1) / weights) * 10_000) / 10_000,
+                };
+            }),
+            unownedStates: states.filter((state) => state.owner === undefined).map(({ id }) => id),
+        };
+    };
     // Localisation for everything named above.
     add(`${context.localisationRoot}/replace/world_l_english.yml`, localisation([
         ...states.map((state) => [
             `STATE_${state.id}`,
-            stateNames.get(state.id) ??
-                `${countryNames.get(state.owner) ?? state.owner} District ${state.id}`,
+            stateNames.get(state.id) ?? `${ownerName(state)} District ${state.id}`,
         ]),
         ...states.flatMap((state) => [...state.victoryPoints.keys()].map((id) => [
             `VICTORY_POINTS_${provinceId(id)}`,
-            cityNames.get(id) ??
-                `${countryNames.get(state.owner) ?? state.owner} Settlement ${provinceId(id)}`,
+            cityNames.get(id) ?? `${ownerName(state)} Settlement ${provinceId(id)}`,
         ])),
         ...[...regionMembers.keys()]
             .sort((a, b) => a - b)
@@ -1710,9 +1766,13 @@ export function generateWorld(spec, context, options = {}) {
         ...(spec.referenceLabels ?? []).map((label, index) => [`WORLD_GEOGRAPHY_${index + 1}`, label.name]),
         ...continentNames.map((name, index) => [`world_continent_${index + 1}`, name]),
         ...countryLocalisation,
-        ['WORLD_BOOKMARK_NAME', spec.worldName ?? 'A New World'],
-        ['WORLD_BOOKMARK_DESC', 'Nations of an unfamiliar map at the dawn of the war.'],
-        ['WORLD_OTHER_DESC', 'Any other nation of this world.'],
+        ...(spec.realms === undefined
+            ? [
+                ['WORLD_BOOKMARK_NAME', spec.worldName ?? 'A New World'],
+                ['WORLD_BOOKMARK_DESC', 'Nations of an unfamiliar map at the dawn of the war.'],
+                ['WORLD_OTHER_DESC', 'Any other nation of this world.'],
+            ]
+            : []),
         ...majors.map((country) => [
             `${country.tag}_WORLD_DESC`,
             `${country.name} begins the game among the strongest nations.`,
@@ -1735,5 +1795,6 @@ export function generateWorld(spec, context, options = {}) {
             countries: spec.countries.length,
             rivers: riverCount,
         },
+        ...(spec.realms === undefined ? {} : { realms: realmSummary() }),
     };
 }