hoi4-agent-tools 4.5.0 → 4.6.1

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

@@ -7,6 +7,7 @@ import { emptyServiceResult, ServiceError } from '../core/result.js';
 import { setInlineFilesScanned } from '../core/operation-result.js';
 import { PACKAGE_VERSION } from '../version.js';
 import { allocateMapIdentifiersAsync, WORLD_OUTPUT_PATH_SAMPLE, } from './operations.js';
+import { compactTerritoryReport } from './territory-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 +302,9 @@ export async function prepareMapRewrite(nudger, input, context) {
                 semanticDiff: compactSemantic.semantic,
                 semanticDiffCounts: compactSemantic.counts,
                 semanticDiffTruncated: compactSemantic.truncated,
+                ...(planned.plan.territory === undefined
+                    ? {}
+                    : { territory: planned.plan.territory.map(compactTerritoryReport) }),
                 ...worldOutputsData(planned.plan),
             }),
             filesScanned: planned.filesScanned,
@@ -503,8 +507,79 @@ async function previewGeographyRewrite(nudger, input, context) {
     await context.progress(3, 3, 'Geography model preview complete; workspace files were not changed');
     return result;
 }
+/**
+ * `create_world.synthesisCheck`: run the model's relief and river synthesis only and report every
+ * river that cannot reach its mouth, with its divide. No map is generated and nothing is written.
+ */
+async function previewSynthesisCheck(nudger, input, context) {
+    await context.progress(0, 2, 'Synthesising relief and rivers to check every river');
+    const checked = await nudger.checkSynthesis({
+        workspaceId: context.workspaceId,
+        operations: input.operations,
+        ...(context.principal === undefined ? {} : { principal: context.principal }),
+        ...(context.signal === undefined ? {} : { signal: context.signal }),
+    });
+    const blocked = checked.diagnostics.filter(({ severity }) => severity === 'error' || severity === 'blocker');
+    const valid = blocked.length === 0 && checked.plan.blockers.length === 0;
+    const rivers = checked.diagnostics.flatMap(({ code, details }) => code === 'MAP_RIVER_UNREACHABLE_MOUTH' && Array.isArray(details?.rivers)
+        ? details.rivers
+        : []);
+    // Drawn rivers are authoritative: crossings of relief they cut through are warnings (ADR 0071).
+    const carved = checked.diagnostics.flatMap(({ code, details }) => code === 'MAP_RIVER_CARVED_CROSSING' && details !== undefined ? [details] : []);
+    const compactSemantic = compactMapSemanticDiff(EMPTY_SEMANTIC_DIFF);
+    const result = emptyServiceResult(context.workspaceId, {
+        execution: 'preview',
+        allocations: [],
+        operationBlockers: [],
+        expectedChangedBounds: null,
+        changedProvinceIds: [],
+        changedProvinceCount: 0,
+        semanticDiff: compactSemantic.semantic,
+        semanticDiffCounts: compactSemantic.counts,
+        semanticDiffTruncated: compactSemantic.truncated,
+        fileCount: 0,
+        artifactCount: checked.artifacts.length,
+        geography: checked.geography.slice(0, 16).map(geographySummary),
+        synthesisCheck: {
+            passed: valid,
+            unreachableRivers: rivers.length,
+            rivers: rivers.slice(0, 200),
+            carvedCrossings: carved.length,
+            crossings: carved.slice(0, 200),
+        },
+    });
+    result.status = valid ? 'ok' : 'blocked';
+    result.code = valid ? 'MAP_SYNTHESIS_CHECK_READY' : 'MAP_SYNTHESIS_CHECK_BLOCKED';
+    setInlineFilesScanned(result, checked.filesScanned);
+    result.proposedFiles = [];
+    result.diagnostics = checked.diagnostics.slice(0, 100);
+    result.artifacts = checked.artifacts.map(publicArtifactLink);
+    result.validation = {
+        passed: valid,
+        checks: [
+            {
+                id: 'river-synthesis',
+                passed: valid,
+                message: valid
+                    ? 'Every river of the model reaches its mouth'
+                    : `${rivers.length || blocked.length} river(s) or model parts block the synthesis; see MAP_RIVER_UNREACHABLE_MOUTH details.rivers`,
+            },
+        ],
+    };
+    result.blockers = [
+        ...checked.plan.blockers.map(({ code, message, details }) => ({
+            code,
+            message,
+            ...(details === undefined ? {} : { details }),
+        })),
+    ].slice(0, 100);
+    await context.progress(2, 2, 'River check complete; nothing was written');
+    return result;
+}
 /** Generate and validate the same proposed map without creating a write transaction. */
 export async function previewMapRewrite(nudger, input, context) {
+    if (input.operations.some((operation) => operation.kind === 'create_world' && operation.synthesisCheck === true))
+        return previewSynthesisCheck(nudger, input, context);
     if (input.operations.some((operation) => operation.kind === 'create_world' && operationHasGeography(operation)))
         return previewGeographyRewrite(nudger, input, context);
     await context.progress(0, 5, 'Generating and validating an offline map preview');
@@ -529,6 +604,9 @@ export async function previewMapRewrite(nudger, input, context) {
         semanticDiff: compactSemantic.semantic,
         semanticDiffCounts: compactSemantic.counts,
         semanticDiffTruncated: compactSemantic.truncated,
+        ...(planned.plan.territory === undefined
+            ? {}
+            : { territory: planned.plan.territory.map(compactTerritoryReport) }),
         fileCount: planned.plan.changes.length,
         artifactCount: planned.artifacts.length,
         ...worldOutputsData(planned.plan),

package/dist/hoi4_agent_tools/map/validation.js

@@ -3,6 +3,7 @@ import { sortDiagnostics } from '../core/diagnostics.js';
 import { assertRenderDimensions } from '../core/render-budget.js';
 import { addActiveMapDiagnostic, addMapDiagnostic } from './diagnostic-limit.js';
 import { validateAppearance } from './appearance-validation.js';
+import { validateCrossings } from './gameplay/crossing-validation.js';
 import { rgbKey } from './bmp.js';
 import { MAP_PROVINCE_ENGINE_MAX_PIXELS } from './model.js';
 const MAP_DIAGNOSTIC_DETAIL_SAMPLE_LIMIT = 100;
@@ -1206,6 +1207,8 @@ function* validateMapSteps(index, options = {}) {
     yield* cancellationCheckpoint(options.signal);
     yield* validateNetworksAndAdjacencies(index, diagnostics, options);
     yield* cancellationCheckpoint(options.signal);
+    yield* validateCrossings(index, (diagnostic) => addDiagnostic(diagnostics, options, { ...diagnostic, category: 'map' }));
+    yield* cancellationCheckpoint(options.signal);
     yield* validatePositions(index, diagnostics, options);
     yield* cancellationCheckpoint(options.signal);
     yield* validateAppearance(index, (diagnostic) => addDiagnostic(diagnostics, options, { ...diagnostic, category: 'map' }), { signal: options.signal, edgeMode: options.edgeMode });
@@ -1247,6 +1250,7 @@ function* validateMapSteps(index, options = {}) {
             passed: !sorted.some(({ code, severity }) => (severity === 'error' || severity === 'blocker') &&
                 (code.startsWith('MAP_ADJACENCY') ||
                     code.startsWith('MAP_IMPASSABLE') ||
+                    code.startsWith('MAP_STRAIT') ||
                     code.startsWith('MAP_SEA_ADJACENCY') ||
                     code.startsWith('MAP_SUPPLY') ||
                     code.startsWith('MAP_RAILWAY'))),

package/dist/hoi4_agent_tools/map/world.js

@@ -12,13 +12,19 @@ import { generateWorldProvinces } from './world-provinces.js';
 import { clusterRegions, clusterStates, partitionWorldFromRequest, } from './partition.js';
 import { repairSeamCorners, smoothDiagonalContacts } from './partition-fields.js';
 import { PARTITION_PROVINCE_ERROR, PARTITION_PROVINCE_WARNING } from './partition-tuning.js';
+import { buildTerritoryAtoms, territoryGraphFromPartition } from './territory-graph.js';
+import { growTerritory } from './territory.js';
 import { geographyPartitionFields, provinceCountNote, surfacePartitionFields, } from './world-partition.js';
+import { adjacencyRowText, adjacencyRulesText } from './gameplay/crossings.js';
+import { convertInlandSeas } from './gameplay/inland-sea.js';
+import { planEconomy } from './gameplay/economy.js';
+import { prepareGameplay } from './gameplay/prepare.js';
 import { fractal, lattice } from './world-noise.js';
 import { calibratedColourMap, COLOUR_CLASSES, } from './colormap.js';
 import { ambientObjectText, applyEdgePolicy, assertFeaturesOutsideBand, edgeWaterDarkness, RIM_COLOUR_FACTOR, rimAdjacencyRows, rimHeight, rimStrength, } from './world-edge.js';
 import { landDistanceField, lakeHeight, normalizeLakes, waterColourLevel } from './water.js';
 import { overlayGeographyLakes, rasterizeGeographyKind } from './relief/land.js';
-import { synthesizeTerrain } from './relief/terrain-synthesis.js';
+import { checkTerrainRivers, synthesizeTerrain, } from './relief/terrain-synthesis.js';
 import { assignUnreachedRealmLand, resolveRealmRules } from './world-realms.js';
 // ---------------------------------------------------------------------------------------------
 // Deterministic randomness and noise
@@ -507,6 +513,48 @@ export function generateWorld(spec, context, options = {}) {
     let seamRepaired = geography !== undefined ? repairSeamCorners(surface.kind, width, height) : [];
     // A geography model gets its relief and rivers from the synthesis of ADR 0056; every other world
     // keeps the original elevation classes and drainage, byte for byte.
+    if (options.riverCheck === true && geography !== undefined) {
+        const checked = checkTerrainRivers({
+            geography,
+            width,
+            height,
+            seed: spec.seed,
+            kind: surface.kind,
+            relief: spec.relief,
+            rivers: { density: spec.riverDensity, count: spec.riverCount },
+            adjustHeight: edge.mode === 'rim'
+                ? (x, _y, value) => rimHeight(value, rimStrength(edge, width, x))
+                : undefined,
+            signal: options.signal,
+        });
+        for (const note of checked) {
+            if (note.severity === 'error')
+                throw new ServiceError(note.code, note.message, note.details);
+            notes.push({
+                code: note.code,
+                severity: note.severity,
+                message: note.message,
+                ...(note.details === undefined ? {} : { details: note.details }),
+            });
+        }
+        return {
+            files: [],
+            warnings: [],
+            notes,
+            summary: {
+                width,
+                height,
+                landProvinces: 0,
+                seaProvinces: 0,
+                lakeProvinces: 0,
+                states: 0,
+                landRegions: 0,
+                seaRegions: 0,
+                countries: spec.countries.length,
+                rivers: 0,
+            },
+        };
+    }
     const synthesized = geography === undefined
         ? undefined
         : synthesizeTerrain({
@@ -535,6 +583,26 @@ export function generateWorld(spec, context, options = {}) {
         }
         notes.push(terrainSummaryNote(synthesized, geography));
     }
+    // A lake the model calls an inland sea becomes navigable water (ADR 0062).
+    const inland = geography === undefined || synthesized === undefined
+        ? undefined
+        : convertInlandSeas(surface.kind, surface.elevation, width, height, geography);
+    if (inland !== undefined && geography !== undefined) {
+        for (const { lake, pixels } of inland.converted)
+            notes.push({
+                code: 'MAP_INLAND_SEA_CREATED',
+                severity: 'info',
+                message: `Lake ${geography.lakes[lake].id} is an inland sea: its ${pixels} water pixels are written as sea provinces so ships and ports can use them`,
+                details: { lakeId: geography.lakes[lake].id, pixels },
+            });
+        for (const lake of inland.missing)
+            notes.push({
+                code: 'MAP_INLAND_SEA_NO_WATER',
+                severity: 'info',
+                message: `Lake ${geography.lakes[lake].id} is an inland sea but has no separate water body: it joined the open sea or was too small to keep`,
+                details: { lakeId: geography.lakes[lake].id },
+            });
+    }
     const drainage = synthesized === undefined
         ? generateWorldDrainage({
             width,
@@ -628,6 +696,25 @@ export function generateWorld(spec, context, options = {}) {
     const countNote = provinceCountNote(count, featurePartition === undefined ? 'legacy' : 'feature-aware');
     if (countNote !== undefined)
         notes.push(countNote);
+    // Crossings, passes and walls of a geography world (ADR 0062).
+    const gameplay = geography === undefined || synthesized === undefined
+        ? undefined
+        : prepareGameplay({
+            width,
+            height,
+            geography,
+            provinces,
+            heights: synthesized.heights,
+            riverBitmap: drainage.riverPixels,
+            fields: synthesized.fields,
+            riverPaths: synthesized.riverPaths,
+            autoStraits: spec.autoStraits,
+            impassableLimit: spec.impassableRowLimit,
+            inlandSeas: inland?.converted.map(({ lake }) => lake) ?? [],
+        });
+    if (gameplay !== undefined)
+        for (const note of gameplay.notes)
+            notes.push(note);
     const center = (id) => ({
         x: provinces.sumX[id] / provinces.size[id],
         y: provinces.sumY[id] / provinces.size[id],
@@ -834,7 +921,20 @@ export function generateWorld(spec, context, options = {}) {
         }
         return selected;
     };
-    const namedCities = (spec.referenceCities ?? []).map((city) => {
+    // Sites of the model that anchor a country (its capital) choose that country's capital province.
+    const siteAnchors = geography === undefined
+        ? []
+        : geography.sites.flatMap((site) => site.country === undefined || site.onWater
+            ? []
+            : [
+                {
+                    name: site.name ?? site.id,
+                    x: site.at.x * width,
+                    y: site.at.y * height,
+                    countryTag: site.country,
+                },
+            ]);
+    const namedCities = [...(spec.referenceCities ?? []), ...siteAnchors].map((city) => {
         const pixel = city.x >= 0 && city.y >= 0 && city.x < width && city.y < height
             ? Math.floor(city.y) * width + Math.floor(city.x)
             : undefined;
@@ -909,7 +1009,22 @@ export function generateWorld(spec, context, options = {}) {
                 .flatMap(([id]) => [...provinces.neighbors[id]]);
         return [...provinces.neighbors[capital]];
     });
-    for (;;) {
+    let grownByTerritory = false;
+    // The feature-aware partition grows generated countries along its natural lines (ADR 0060).
+    // Workspace-owned countries keep the realm growth with its forced and blocked land (ADR 0069).
+    if (featurePartition !== undefined && referenceOwners.size === 0 && realmRules === undefined) {
+        const atoms = buildTerritoryAtoms(territoryGraphFromPartition(featurePartition.graph, provinces.sumX, provinces.sumY), landIds.map((id) => [id]));
+        const grown = growTerritory(atoms, spec.countries.map((country, index) => ({
+            tag: country.tag,
+            weight: shares[index],
+            seeds: [atoms.atomOfProvince[capitals[index]]],
+        })), { seed: spec.seed });
+        for (const [atom, id] of landIds.entries())
+            if (grown.owner[atom] >= 0)
+                owner.set(id, grown.owner[atom]);
+        grownByTerritory = true;
+    }
+    while (!grownByTerritory) {
         let chosen = -1;
         for (let index = 0; index < countryCount; index += 1) {
             frontiers[index] = frontiers[index].filter((id) => provinces.kind[id] === LAND && !owner.has(id) && !blockedFor(index, id));
@@ -1015,12 +1130,33 @@ export function generateWorld(spec, context, options = {}) {
                 resources: new Map(),
                 victoryPoints: new Map(),
                 navalBases: new Map(),
+                forts: new Map(),
             };
             states.push(draft);
             for (const id of sorted)
                 stateOf.set(id, draft);
         }
     }
+    // Names from reference labels (the nearest province to each label), which win over any other.
+    const stateNames = new Map();
+    const regionNames = new Map();
+    for (const label of spec.referenceLabels ?? []) {
+        if (label.kind === 'state') {
+            const nearby = nearestProvince(label, landIds);
+            const state = stateOf.get(nearby);
+            const previous = stateNames.get(state.id);
+            stateNames.set(state.id, previous === undefined ? label.name : `${previous} / ${label.name}`);
+        }
+        else if (label.kind === 'sea' || label.kind === 'region') {
+            const members = label.kind === 'sea' ? seaIds : landIds;
+            if (members.length === 0)
+                continue;
+            const region = regionOf.get(nearestProvince(label, members));
+            const previous = regionNames.get(region);
+            regionNames.set(region, previous === undefined ? label.name : `${previous} / ${label.name}`);
+        }
+    }
+    const lakeNames = new Map();
     // State values from size, terrain and development, with the country capital boosted.
     const categories = [
         'wasteland',
@@ -1048,112 +1184,153 @@ export function generateWorld(spec, context, options = {}) {
         state.capital = capital;
         countryCapitalState.set(spec.countries[index].tag, state);
     }
-    for (const state of states) {
-        const pixels = state.provinces.reduce((sum, id) => sum + provinces.size[id], 0);
-        const habitability = state.provinces.reduce((sum, id) => {
-            const value = {
-                plains: 1,
-                forest: 0.8,
-                hills: 0.6,
-                jungle: 0.5,
-                marsh: 0.4,
-                desert: 0.25,
-                mountain: 0.3,
-                urban: 1.5,
-            }[terrain.get(id) ?? 'plains'] ?? 0.5;
-            return sum + value * provinces.size[id];
-        }, 0) / pixels;
-        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))));
-        state.category = categories[categoryIndex];
-        if (context.stateCategories !== undefined && !context.stateCategories.has(state.category))
-            state.category = context.stateCategories.has('rural')
-                ? 'rural'
-                : ([...context.stateCategories][0] ?? 'rural');
-        const slots = slotsFor[state.category] ?? 2;
-        state.infrastructure = Math.max(1, Math.min(5, Math.round(1 + development * 3 + (isCapital ? 1 : 0))));
-        state.civilian = Math.round(slots * (0.25 + random.next() * 0.3));
-        state.military = Math.min(slots - state.civilian, Math.round(slots * random.next() * 0.3));
-        if (isCapital) {
-            terrain.set(state.capital, 'urban');
-            state.airBase = 2;
-        }
-        const coastalProvinces = state.provinces.filter(coastal);
-        if (coastalProvinces.length > 0 && (isCapital || random.next() < 0.35)) {
-            state.navalBases.set(coastalProvinces[0], isCapital ? 3 : 1);
-            if (slots - state.civilian - state.military > 0 && random.next() < 0.5)
-                state.dockyard = 1;
-        }
-        for (const id of state.provinces) {
-            const kindOfLand = terrain.get(id);
-            const roll = random.next();
-            const add = (resource, amount) => state.resources.set(resource, (state.resources.get(resource) ?? 0) + amount);
-            if (kindOfLand === 'desert' && roll < 0.3)
-                add('oil', 2 + random.int(6));
-            if ((kindOfLand === 'mountain' || kindOfLand === 'hills') && roll < 0.35)
-                add('steel', 2 + random.int(8));
-            if (kindOfLand === 'mountain' && roll < 0.15)
-                add('tungsten', 1 + random.int(4));
-            if (kindOfLand === 'hills' && roll > 0.85)
-                add('chromium', 1 + random.int(4));
-            if (kindOfLand === 'jungle' && roll < 0.35)
-                add('rubber', 1 + random.int(5));
-            if (kindOfLand === 'plains' && roll < 0.05)
-                add('aluminium', 1 + random.int(4));
-        }
-        state.victoryPoints.set(state.capital, isCapital ? 25 : Math.max(1, Math.round(development * 8)));
-    }
     const cityNames = new Map();
-    for (const city of namedCities) {
-        const state = stateOf.get(city.province);
-        cityNames.set(city.province, city.name);
-        state.victoryPoints.set(city.province, Math.max(5, state.victoryPoints.get(city.province) ?? 0));
-        terrain.set(city.province, 'urban');
-    }
-    // Each coastal territory needs a port even when its capital lies inland or on another island.
-    const portChecked = new Set();
-    for (const start of landIds) {
-        if (portChecked.has(start))
-            continue;
-        const queue = [start];
-        portChecked.add(start);
-        let bestCoast;
-        let hasPort = false;
-        for (const id of queue) {
-            if (stateOf.get(id).navalBases.has(id))
-                hasPort = true;
-            if (coastal(id) &&
-                (bestCoast === undefined || provinces.size[id] > provinces.size[bestCoast]))
-                bestCoast = id;
-            for (const next of provinces.neighbors[id])
-                if (!portChecked.has(next) &&
-                    provinces.kind[next] === LAND &&
-                    owner.get(next) === owner.get(start)) {
-                    portChecked.add(next);
-                    queue.push(next);
-                }
+    // A geography world gets its economy, ports, names and railway costs from the model (ADR 0063);
+    // every other world keeps the random economy below, byte for byte.
+    const economy = gameplay === undefined || spec.developmentModel === 'legacy'
+        ? undefined
+        : planEconomy(gameplay, {
+            states: states.map((state) => ({
+                id: state.id,
+                provinces: state.provinces,
+                owner: state.owner,
+                isCapital: state.owner !== undefined && countryCapitalState.get(state.owner) === state,
+            })),
+            terrain,
+            options: {
+                categories,
+                slotsFor,
+                allowedCategories: context.stateCategories,
+                capitalProvinces: new Set(capitals),
+            },
+            regionOf,
+            fixedStateNames: stateNames,
+            fixedRegionNames: regionNames,
+            countryNames: new Map(spec.countries.map(({ tag, name }) => [tag, name])),
+        });
+    if (economy !== undefined) {
+        for (const state of states) {
+            const plan = economy.development.states.get(state.id);
+            state.manpower = plan.manpower;
+            state.category = plan.category;
+            state.infrastructure = plan.infrastructure;
+            state.civilian = plan.civilian;
+            state.military = plan.military;
+            state.dockyard = plan.dockyard;
+            state.airBase = plan.airBase;
+            state.resources = plan.resources;
+            state.victoryPoints = plan.victoryPoints;
+            for (const id of state.provinces) {
+                const port = economy.ports.ports.get(id);
+                if (port !== undefined)
+                    state.navalBases.set(id, port.level);
+                const fort = economy.forts.get(id);
+                if (fort !== undefined)
+                    state.forts.set(id, fort);
+            }
         }
-        if (!hasPort && bestCoast !== undefined)
-            stateOf.get(bestCoast).navalBases.set(bestCoast, 1);
+        for (const id of economy.development.urban)
+            terrain.set(id, 'urban');
+        for (const [id, name] of economy.names.victory)
+            cityNames.set(id, name);
+        for (const [id, name] of economy.names.states)
+            stateNames.set(id, name);
+        for (const [id, name] of economy.names.regions)
+            regionNames.set(id, name);
+        for (const [id, name] of economy.names.lakes)
+            lakeNames.set(id, name);
+        for (const note of economy.notes)
+            notes.push(note);
     }
-    const stateNames = new Map();
-    const regionNames = new Map();
-    for (const label of spec.referenceLabels ?? []) {
-        if (label.kind === 'state') {
-            const nearby = nearestProvince(label, landIds);
-            const state = stateOf.get(nearby);
-            const previous = stateNames.get(state.id);
-            stateNames.set(state.id, previous === undefined ? label.name : `${previous} / ${label.name}`);
+    if (economy === undefined) {
+        for (const state of states) {
+            const pixels = state.provinces.reduce((sum, id) => sum + provinces.size[id], 0);
+            const habitability = state.provinces.reduce((sum, id) => {
+                const value = {
+                    plains: 1,
+                    forest: 0.8,
+                    hills: 0.6,
+                    jungle: 0.5,
+                    marsh: 0.4,
+                    desert: 0.25,
+                    mountain: 0.3,
+                    urban: 1.5,
+                }[terrain.get(id) ?? 'plains'] ?? 0.5;
+                return sum + value * provinces.size[id];
+            }, 0) / pixels;
+            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))));
+            state.category = categories[categoryIndex];
+            if (context.stateCategories !== undefined && !context.stateCategories.has(state.category))
+                state.category = context.stateCategories.has('rural')
+                    ? 'rural'
+                    : ([...context.stateCategories][0] ?? 'rural');
+            const slots = slotsFor[state.category] ?? 2;
+            state.infrastructure = Math.max(1, Math.min(5, Math.round(1 + development * 3 + (isCapital ? 1 : 0))));
+            state.civilian = Math.round(slots * (0.25 + random.next() * 0.3));
+            state.military = Math.min(slots - state.civilian, Math.round(slots * random.next() * 0.3));
+            if (isCapital) {
+                terrain.set(state.capital, 'urban');
+                state.airBase = 2;
+            }
+            const coastalProvinces = state.provinces.filter(coastal);
+            if (coastalProvinces.length > 0 && (isCapital || random.next() < 0.35)) {
+                state.navalBases.set(coastalProvinces[0], isCapital ? 3 : 1);
+                if (slots - state.civilian - state.military > 0 && random.next() < 0.5)
+                    state.dockyard = 1;
+            }
+            for (const id of state.provinces) {
+                const kindOfLand = terrain.get(id);
+                const roll = random.next();
+                const add = (resource, amount) => state.resources.set(resource, (state.resources.get(resource) ?? 0) + amount);
+                if (kindOfLand === 'desert' && roll < 0.3)
+                    add('oil', 2 + random.int(6));
+                if ((kindOfLand === 'mountain' || kindOfLand === 'hills') && roll < 0.35)
+                    add('steel', 2 + random.int(8));
+                if (kindOfLand === 'mountain' && roll < 0.15)
+                    add('tungsten', 1 + random.int(4));
+                if (kindOfLand === 'hills' && roll > 0.85)
+                    add('chromium', 1 + random.int(4));
+                if (kindOfLand === 'jungle' && roll < 0.35)
+                    add('rubber', 1 + random.int(5));
+                if (kindOfLand === 'plains' && roll < 0.05)
+                    add('aluminium', 1 + random.int(4));
+            }
+            state.victoryPoints.set(state.capital, isCapital ? 25 : Math.max(1, Math.round(development * 8)));
         }
-        else if (label.kind === 'sea' || label.kind === 'region') {
-            const members = label.kind === 'sea' ? seaIds : landIds;
-            if (members.length === 0)
+        for (const city of namedCities) {
+            const state = stateOf.get(city.province);
+            cityNames.set(city.province, city.name);
+            state.victoryPoints.set(city.province, Math.max(5, state.victoryPoints.get(city.province) ?? 0));
+            terrain.set(city.province, 'urban');
+        }
+        // Each coastal territory needs a port even when its capital lies inland or on another island.
+        const portChecked = new Set();
+        for (const start of landIds) {
+            if (portChecked.has(start))
                 continue;
-            const region = regionOf.get(nearestProvince(label, members));
-            const previous = regionNames.get(region);
-            regionNames.set(region, previous === undefined ? label.name : `${previous} / ${label.name}`);
+            const queue = [start];
+            portChecked.add(start);
+            let bestCoast;
+            let hasPort = false;
+            for (const id of queue) {
+                if (stateOf.get(id).navalBases.has(id))
+                    hasPort = true;
+                if (coastal(id) &&
+                    (bestCoast === undefined || provinces.size[id] > provinces.size[bestCoast]))
+                    bestCoast = id;
+                for (const next of provinces.neighbors[id])
+                    if (!portChecked.has(next) &&
+                        provinces.kind[next] === LAND &&
+                        owner.get(next) === owner.get(start)) {
+                        portChecked.add(next);
+                        queue.push(next);
+                    }
+            }
+            if (!hasPort && bestCoast !== undefined)
+                stateOf.get(bestCoast).navalBases.set(bestCoast, 1);
         }
     }
     // Province IDs: 1-based in reading order of the province's first pixel; 0 is the null row.
@@ -1222,8 +1399,11 @@ export function generateWorld(spec, context, options = {}) {
             message: `The rim edge policy wrote ${rimRows.length} impassable adjacency row(s) for provinces that meet across the seam`,
             details: { rows: rimRows.length },
         });
-    add(`${map}/adjacencies.csv`, text(`From;To;Type;Through;start_x;start_y;stop_x;stop_y;adjacency_rule_name;Comment\r\n${rimRows.map((row) => `${row}\r\n`).join('')}-1;-1;;-1;-1;-1;-1;-1;-1\r\n`));
-    add(`${map}/adjacency_rules.txt`, text('# No straits or canals in this world yet.\n'));
+    const crossingRows = (gameplay?.crossings.rows ?? []).map(adjacencyRowText);
+    add(`${map}/adjacencies.csv`, text(`From;To;Type;Through;start_x;start_y;stop_x;stop_y;adjacency_rule_name;Comment\r\n${[...crossingRows, ...rimRows].map((row) => `${row}\r\n`).join('')}-1;-1;;-1;-1;-1;-1;-1;-1\r\n`));
+    add(`${map}/adjacency_rules.txt`, text(gameplay === undefined
+        ? '# No straits or canals in this world yet.\n'
+        : adjacencyRulesText(gameplay.crossings.rules)));
     add(`${map}/positions.txt`, text(''));
     add(`${map}/ambient_object.txt`, text(spec.ambientFrame === true
         ? ambientObjectText(width, height)
@@ -1562,7 +1742,16 @@ export function generateWorld(spec, context, options = {}) {
             ...(state.military > 0 ? [`\t\t\tarms_factory = ${state.military}`] : []),
             ...(state.dockyard > 0 ? [`\t\t\tdockyard = ${state.dockyard}`] : []),
             ...(state.airBase > 0 ? [`\t\t\tair_base = ${state.airBase}`] : []),
-            ...[...state.navalBases].map(([id, level]) => `\t\t\t${provinceId(id)} = { naval_base = ${level} }`),
+            ...[
+                ...state.navalBases.keys(),
+                ...[...state.forts.keys()].filter((id) => !state.navalBases.has(id)).sort((a, b) => a - b),
+            ].map((id) => {
+                const parts = [
+                    ...(state.navalBases.has(id) ? [`naval_base = ${state.navalBases.get(id)}`] : []),
+                    ...(state.forts.has(id) ? [`bunker = ${state.forts.get(id)}`] : []),
+                ];
+                return `\t\t\t${provinceId(id)} = { ${parts.join(' ')} }`;
+            }),
         ];
         add(`${context.statesRoot}/${state.id}-${slug(stateNames.get(state.id) ?? `STATE_${state.id}`).slice(0, 80)}.txt`, text([
             'state = {',
@@ -1764,6 +1953,9 @@ export function generateWorld(spec, context, options = {}) {
             .sort((a, b) => a - b)
             .map((region) => [`STRATEGICREGION_${region}`, regionNames.get(region) ?? `Region ${region}`]),
         ...(spec.referenceLabels ?? []).map((label, index) => [`WORLD_GEOGRAPHY_${index + 1}`, label.name]),
+        ...[...lakeNames]
+            .sort((a, b) => a[0] - b[0])
+            .map(([id, name]) => [`PROV${provinceId(id)}`, name]),
         ...continentNames.map((name, index) => [`world_continent_${index + 1}`, name]),
         ...countryLocalisation,
         ...(spec.realms === undefined
@@ -1783,6 +1975,8 @@ export function generateWorld(spec, context, options = {}) {
         warnings: [...interpretationWarnings, ...drainage.warnings],
         notes,
         ...(synthesized === undefined ? {} : { terrain: synthesized }),
+        ...(economy === undefined ? {} : { railCost: economy.railCost }),
+        ...(gameplay === undefined ? {} : { gameplay: { crossings: gameplay.crossings, economy } }),
         summary: {
             width,
             height,

package/dist/hoi4_agent_tools/reference/known-mistakes.js

@@ -256,6 +256,9 @@ const detectors = {
         const findings = [];
         for (const { node, token } of names) {
             const name = token.slice(token.lastIndexOf('.') + 1);
+            // `constant:category.key` reads a script constant, not a scoped variable.
+            if (token.startsWith('constant:'))
+                continue;
             if (!temporary.has(name) || regular.has(name))
                 continue;
             if (!/^(?:[A-Za-z_][\w]*|[a-z_]+:[\w]+)(?:\.[A-Za-z_][\w]*)+$/u.test(token))