hoi4-agent-tools 4.3.0 → 4.4.0

package/dist/hoi4_agent_tools/map/model.js

@@ -87,7 +87,11 @@ export function selectActiveFiles(files) {
 }
 export function parseTextDocument(file) {
     if (file.bytes.length > MAP_TEXT_MAX_BYTES) {
-        throw new ServiceError('MAP_TEXT_FILE_LIMIT', 'Map text table exceeds the supported 16 MiB parsing limit', { bytes: file.bytes.length, maximumBytes: MAP_TEXT_MAX_BYTES });
+        throw new ServiceError('MAP_TEXT_FILE_LIMIT', `Map text table ${file.relativePath} exceeds the supported 16 MiB parsing limit (${file.bytes.length} bytes)`, {
+            relativePath: file.relativePath,
+            bytes: file.bytes.length,
+            maximumBytes: MAP_TEXT_MAX_BYTES,
+        });
     }
     const decoded = decodeSource(file.bytes);
     const lines = [];
@@ -101,7 +105,11 @@ export function parseTextDocument(file) {
         const text = full.replace(/(?:\r\n|\n|\r)$/u, '');
         const start = match.index;
         if (index >= MAP_TEXT_MAX_RECORDS) {
-            throw new ServiceError('MAP_TEXT_RECORD_LIMIT', 'Map text table exceeds the supported record limit', { records: index + 1, maximumRecords: MAP_TEXT_MAX_RECORDS });
+            throw new ServiceError('MAP_TEXT_RECORD_LIMIT', `Map text table ${file.relativePath} exceeds the supported record limit`, {
+                relativePath: file.relativePath,
+                records: index + 1,
+                maximumRecords: MAP_TEXT_MAX_RECORDS,
+            });
         }
         lines.push({ index, start, end: start + text.length, fullEnd: start + full.length, text });
         index += 1;
@@ -1114,6 +1122,9 @@ export class MapWorkspaceIndex {
     railwayFile;
     /** The active heightmap, when the scan included it; decoded on first use. */
     heightmapFile;
+    /** The active river and terrain bitmaps, when the scan included them (border quality). */
+    riversFile;
+    terrainBitmapFile;
     #heightmap;
     /**
      * Map height (the Y coordinate) at a bitmap pixel: the heightmap value divided by ten, as the
@@ -1297,6 +1308,8 @@ export class MapWorkspaceIndex {
                 ? undefined
                 : parseTerrainCategories(terrainFiles, this.diagnostics);
         this.heightmapFile = mapFile(this.activeFiles, defaultMapSelectorValue(this.defaultMapFile, 'heightmap', 'heightmap.bmp'), this.sourceRoots.map);
+        this.riversFile = mapFile(this.activeFiles, defaultMapSelectorValue(this.defaultMapFile, 'rivers', 'rivers.bmp'), this.sourceRoots.map);
+        this.terrainBitmapFile = mapFile(this.activeFiles, defaultMapSelectorValue(this.defaultMapFile, 'terrain', 'terrain.bmp'), this.sourceRoots.map);
         const buildingFiles = this.activeFiles.all.filter((file) => /^common\/buildings\/[^/]+\.txt$/iu.test(normalizedPath(file.relativePath)));
         const buildings = parseBuildingDefinitions(buildingFiles, []);
         this.buildingDefinitions = buildings.definitions;

package/dist/hoi4_agent_tools/map/operations.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
-import { compareCodeUnits, deterministicId, sha256Bytes } from '../core/canonical.js';
+import { canonicalJson, compareCodeUnits, deterministicId, sha256Bytes, } from '../core/canonical.js';
 import { ServiceError } from '../core/result.js';
 import { applyReplacements, assignments, encodeSource, parseLocalisation, parseClausewitz, } from '../core/source/index.js';
 import { rgbKey } from './bmp.js';
@@ -8,9 +8,12 @@ import { MAP_MASK_CELL_LIMIT, MAP_POLYGON_WORK_LIMIT, MAP_SELECTED_OFFSET_BYTES,
 import { derivedStateCapital, encodeTextDocument, LEVEL_STATE_BUILDINGS, MapWorkspaceIndex, parseMapDate, parseTextDocument, } from './model.js';
 import { planReferenceRemap, ReferenceRemapError } from './references.js';
 import { generateWorld } from './world.js';
+import { resolveEdge } from './world-edge.js';
 import { planMapPositions, planSupplyRebuild } from './derived.js';
 import { buildWorldContext } from './world-context.js';
 import { reconcileWorldOutputs } from './world-outputs.js';
+import { resolvePartitionMode } from './partition.js';
+import { unsupportedGeographyParts } from './relief/index.js';
 function* cancellationCheckpoint(signal, iteration = 0, stride = 1) {
     if (iteration % stride !== 0)
         return;
@@ -3272,23 +3275,60 @@ function descriptorWithReplacePaths(index, roots) {
     const body = textValue.endsWith('\n') ? textValue : `${textValue}${newline}`;
     return Buffer.from(`${body}${missing.map((root) => `replace_path="${root}"`).join(newline)}${missing.length > 0 ? newline : ''}`, 'utf8');
 }
-function applyCreateWorld(base, changes, operation, context) {
+function colormapPaletteOverrides(palette) {
+    return Object.fromEntries(Object.entries(palette).flatMap(([name, color]) => color === undefined ? [] : [[name, [color.r, color.g, color.b]]]));
+}
+function applyCreateWorld(base, changes, operation, context, signal) {
+    const geography = context.geographyModels?.get(operation.id);
+    const hasGeography = operation.geography !== undefined || operation.geographyPath !== undefined;
+    if (hasGeography) {
+        if (geography === undefined)
+            throw new ServiceError('MAP_GEOGRAPHY_NOT_PREPARED', 'Geography models must be prepared by the authorized workspace service');
+        if (!geography.valid)
+            throw new ServiceError('MAP_GEOGRAPHY_INVALID', 'The geography model has errors; fix them (see the MAP_GEOGRAPHY_* diagnostics and map-geography-report.json) before generating a world', { modelHash: geography.geography.hash });
+        const pending = unsupportedGeographyParts(geography.geography);
+        if (pending.length > 0)
+            throw new ServiceError('MAP_GEOGRAPHY_SYNTHESIS_UNAVAILABLE', `The geography model is valid and its relief, rivers and lakes can be synthesized, but this version cannot yet use ${pending.join(', ')} (the climate and biome stage); remove them from the model to generate relief and rivers only, or use preview:true to review the model overlay and report`, {
+                modelHash: geography.geography.hash,
+                available: ['relief', 'rivers', 'lakes'],
+                unavailable: pending,
+            });
+    }
+    else {
+        if (operation.relief !== undefined)
+            throw new ServiceError('MAP_RELIEF_REQUIRES_GEOGRAPHY', 'relief shapes the terrain synthesised from a geography model; give geography or geographyPath, or remove relief');
+        if (typeof operation.rivers === 'object')
+            throw new ServiceError('MAP_RIVER_DENSITY_REQUIRES_GEOGRAPHY', 'rivers { density } sets the river network of a geography world; give geography or geographyPath, or use an integer count');
+    }
     const reference = context.referenceWorlds?.get(operation.id);
     if (operation.reference !== undefined && reference === undefined)
         throw new ServiceError('MAP_REFERENCE_NOT_PREPARED', 'Reference worlds must be prepared by the authorized workspace service');
     const mapRoot = base.sourceRoots.map[0] ?? 'map';
     const startingScenario = operation.startingScenario ?? reference !== undefined;
+    const worldWidth = operation.width ?? reference?.surface.width ?? 1_024;
+    const worldHeight = operation.height ?? reference?.surface.height ?? 512;
+    const edge = resolveEdge(operation.edge, worldWidth, worldHeight);
+    const look = operation.look;
+    const colormapProfile = operation.colormap?.profile ?? (look === undefined ? 'legacy' : 'calibrated');
+    if (look === 'custom' && operation.colormap?.palette === undefined)
+        throw new ServiceError('MAP_LOOK_CUSTOM_PALETTE_REQUIRED', 'look "custom" needs colormap.palette with at least one class colour');
+    if (colormapProfile === 'legacy' && look !== undefined)
+        throw new ServiceError('MAP_LOOK_REQUIRES_CALIBRATED_COLORMAP', 'look selects a calibrated palette; remove colormap.profile "legacy" or look');
+    const partitionMode = resolvePartitionMode(operation.partition, hasGeography);
+    if (partitionMode === 'legacy' && operation.partitionTuning !== undefined)
+        throw new ServiceError('MAP_PARTITION_TUNING_REQUIRES_FEATURE_AWARE', 'partitionTuning applies to the feature-aware partition; set partition to "feature-aware" or remove it');
     const world = generateWorld({
         startingScenario,
         ...(operation.worldName === undefined ? {} : { worldName: operation.worldName }),
-        width: operation.width ?? reference?.surface.width ?? 1_024,
-        height: operation.height ?? reference?.surface.height ?? 512,
+        width: worldWidth,
+        height: worldHeight,
         seed: operation.seed ?? 1,
         landCoverage: operation.landCoverage ?? 0.35,
         continents: operation.continents ?? 3,
         ...(operation.landPolygons === undefined ? {} : { landPolygons: operation.landPolygons }),
         landProvincePixels: operation.landProvincePixels ?? 400,
         seaProvincePixels: operation.seaProvincePixels ?? 2_500,
+        provinceSizesDefaulted: operation.landProvincePixels === undefined && operation.seaProvincePixels === undefined,
         provincesPerState: operation.provincesPerState ?? (reference === undefined ? 5 : 12),
         landProvincesPerRegion: operation.landProvincesPerRegion ?? (reference === undefined ? 25 : 60),
         seaProvincesPerRegion: operation.seaProvincesPerRegion ?? (reference === undefined ? 10 : 30),
@@ -3310,8 +3350,47 @@ function applyCreateWorld(base, changes, operation, context) {
             ? {}
             : { continentNames: operation.continentNames }),
         startDate: operation.startDate ?? '1936.1.1',
-        rivers: operation.rivers ?? (reference === undefined ? 8 : 80),
-    }, buildWorldContext(base));
+        rivers: typeof operation.rivers === 'number' ? operation.rivers : reference === undefined ? 8 : 80,
+        ...(geography === undefined
+            ? {}
+            : {
+                geography: geography.geography,
+                ...(operation.relief === undefined
+                    ? {}
+                    : {
+                        relief: {
+                            ...(operation.relief.scale === undefined
+                                ? {}
+                                : { scale: operation.relief.scale }),
+                            ...(operation.relief.detail === undefined
+                                ? {}
+                                : { detail: operation.relief.detail }),
+                        },
+                    }),
+                ...(typeof operation.rivers === 'object'
+                    ? { riverDensity: operation.rivers.density }
+                    : typeof operation.rivers === 'number'
+                        ? { riverCount: operation.rivers }
+                        : {}),
+            }),
+        ...(edge.mode === 'none' ? {} : { edge }),
+        ...(operation.ambientFrame === true ? { ambientFrame: true } : {}),
+        colormapProfile,
+        ...(partitionMode === 'legacy'
+            ? {}
+            : {
+                partition: {
+                    mode: partitionMode,
+                    ...(operation.partitionTuning === undefined
+                        ? {}
+                        : { tuning: operation.partitionTuning }),
+                },
+            }),
+        ...(look === undefined ? {} : { look }),
+        ...(operation.colormap?.palette === undefined
+            ? {}
+            : { colormapPalette: colormapPaletteOverrides(operation.colormap.palette) }),
+    }, buildWorldContext(base), { signal });
     const roots = operation.replaceBaseGame === false
         ? []
         : [...WORLD_REPLACED_ROOTS, ...(startingScenario ? STARTING_SCENARIO_REPLACED_ROOTS : [])];
@@ -3349,6 +3428,14 @@ function applyCreateWorld(base, changes, operation, context) {
             operationId: operation.id,
             message,
         })),
+        ...world.notes.map((note) => ({
+            code: note.code,
+            severity: note.severity,
+            category: 'map',
+            operationId: operation.id,
+            message: note.message,
+            ...(note.details === undefined ? {} : { details: note.details }),
+        })),
         ...(world.warnings.length === 0
             ? []
             : [
@@ -3456,6 +3543,22 @@ function applyEntityLocator(base, changes, operation) {
     ]);
     addChange(changes, locator.file.relativePath, output, operation.id, 'text/plain');
 }
+/**
+ * The operation as the transaction manifest records it. An inline geography model can hold
+ * megabytes; the manifest keeps its SHA-256 and size instead, which still bind the plan hash to
+ * the exact model, and a model given by path is bound by the file's read dependency.
+ */
+function manifestOperationData(operation) {
+    const data = JSON.parse(JSON.stringify(operation));
+    if (operation.kind === 'create_world' && operation.geography !== undefined) {
+        const canonical = canonicalJson(operation.geography);
+        data.geography = {
+            sha256: sha256Bytes(canonical),
+            bytes: Buffer.byteLength(canonical, 'utf8'),
+        };
+    }
+    return data;
+}
 function* planMapOperationSteps(base, operations, signal, context = {}) {
     yield* cancellationCheckpoint(signal);
     const changes = new Map();
@@ -3480,7 +3583,7 @@ function* planMapOperationSteps(base, operations, signal, context = {}) {
             id: operation.id,
             kind: operation.kind,
             summary: operation.summary ?? operation.kind.replaceAll('_', ' '),
-            data: JSON.parse(JSON.stringify(operation)),
+            data: manifestOperationData(operation),
         });
         const changesCheckpoint = new Map([...changes].map(([key, change]) => [
             key,
@@ -3494,7 +3597,7 @@ function* planMapOperationSteps(base, operations, signal, context = {}) {
         const boundsCheckpoint = expectedChangedBounds;
         try {
             if (operation.kind === 'create_world')
-                diagnostics.push(...applyCreateWorld(base, changes, operation, context));
+                diagnostics.push(...applyCreateWorld(base, changes, operation, context, signal));
             else if (operation.kind === 'move_state_provinces')
                 applyMoveStateProvinces(base, changes, operation);
             else if (operation.kind === 'update_state')

package/dist/hoi4_agent_tools/map/partition-fields.js

@@ -0,0 +1,398 @@
+import { ServiceError } from '../core/result.js';
+/**
+ * Inputs of the feature-aware partition (ADR 0058): one byte (or two) per pixel describing the
+ * natural lines and the character of the land, in one typed contract. The contract exists so the
+ * partition does not care where the numbers come from. `partitionFieldsFromBitmaps` computes a
+ * basic version from the height, terrain and river bitmaps a map already has; the generator fills
+ * them from its own rasters and, for a geography world, from the synthesised heights, the model
+ * (`partitionFieldsFromGeography` adds regions and wall ranges) and the lines of the synthesis
+ * (`partitionFieldsWithTerrainLines`). Only `+ - * /` and `sqrt` are used, so every field is
+ * identical on every platform.
+ */
+/** Terrain classes the partition distinguishes; `water` marks pixels that are not land. */
+export const PARTITION_TERRAIN = {
+    plains: 0,
+    farmland: 1,
+    forest: 2,
+    hills: 3,
+    mountain: 4,
+    desert: 5,
+    marsh: 6,
+    jungle: 7,
+    snow: 8,
+    urban: 9,
+    water: 255,
+};
+/** Pixel kinds, as the province generator already uses them. */
+export const PARTITION_KIND = { sea: 0, land: 1, lake: 2 };
+const MAP_PIXEL_LIMIT = 13_238_272;
+function invalid(message, details) {
+    throw new ServiceError('MAP_PARTITION_FIELDS_INVALID', message, details);
+}
+/** Check the sizes, kinds and region table of a set of fields; throws `MAP_PARTITION_FIELDS_INVALID`. */
+export function assertPartitionFields(fields) {
+    const { width, height } = fields;
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width < 16 || height < 16)
+        invalid('Partition dimensions must be integers of at least 16 pixels', { width, height });
+    const total = width * height;
+    if (!Number.isSafeInteger(total) || total > MAP_PIXEL_LIMIT)
+        invalid('Partition dimensions exceed the 13,238,272-pixel map limit', { width, height });
+    const planes = [
+        ['kind', fields.kind, Uint8Array],
+        ['riverDistance', fields.riverDistance, Uint8Array],
+        ['ridge', fields.ridge, Uint8Array],
+        ['slope', fields.slope, Uint8Array],
+        ['terrainClass', fields.terrainClass, Uint8Array],
+        ['regionId', fields.regionId, Uint16Array],
+        ['fertility', fields.fertility, Uint8Array],
+        ['barrier', fields.barrier, Uint8Array],
+    ];
+    for (const [name, plane, type] of planes) {
+        if (!(plane instanceof type))
+            invalid(`Partition field ${name} must be a ${type.name}`, {
+                field: name,
+            });
+        if (plane.length !== total)
+            invalid(`Partition field ${name} does not match the map dimensions`, {
+                field: name,
+                length: plane.length,
+                expected: total,
+            });
+    }
+    for (let p = 0; p < total; p++)
+        if (fields.kind[p] > 2)
+            invalid('Partition kind contains a value other than sea (0), land (1) or lake (2)', {
+                pixel: p,
+                value: fields.kind[p],
+            });
+    const ids = new Set();
+    for (const region of fields.regions ?? []) {
+        if (!Number.isInteger(region.id) || region.id < 1 || region.id > 65_535 || ids.has(region.id))
+            invalid('Partition region ids must be unique integers from 1 to 65,535', { id: region.id });
+        ids.add(region.id);
+        if (region.provinceAreaPx !== undefined &&
+            (!Number.isFinite(region.provinceAreaPx) || region.provinceAreaPx < 20))
+            invalid('A region province area must be at least 20 pixels', { id: region.id });
+        const per = region.provincesPerState;
+        if (per !== undefined &&
+            (per.some((value) => !Number.isInteger(value) || value < 1) ||
+                per[0] > per[1] ||
+                per[1] > per[2]))
+            invalid('A region provincesPerState must be three increasing positive integers', {
+                id: region.id,
+            });
+    }
+    if (ids.size > 0)
+        for (let p = 0; p < total; p++) {
+            const id = fields.regionId[p];
+            if (id !== 0 && !ids.has(id))
+                invalid('A pixel names a region that the region table does not list', { pixel: p, id });
+        }
+}
+// ---------------------------------------------------------------------------------------------
+// Diagonal contacts
+/**
+ * Remove the one mask pattern no partition can represent: a 2 x 2 block whose diagonals are two
+ * kinds (land and sea, say) so that each kind touches itself only at a corner. Four provinces
+ * would meet there ("X crossing"), and neither pair can be merged because the pieces are not
+ * four-connected. One pixel of the non-land kind becomes the other kind (land beats sea and lake, sea
+ * beats lake: the pixel of the weaker kind on the north-east or north-west corner changes),
+ * repeating until no block is left. Returns the changed pixel indices; `kind` is modified in
+ * place. The east-west seam wraps.
+ */
+export function smoothDiagonalContacts(kind, width, height, maxPasses = 8) {
+    const changed = [];
+    for (let pass = 0; pass < maxPasses; pass++) {
+        let found = false;
+        for (let y = 0; y + 1 < height; y++) {
+            const row = y * width;
+            for (let x = 0; x < width; x++) {
+                const next = x + 1 < width ? x + 1 : 0;
+                const nw = row + x;
+                const ne = row + next;
+                const sw = nw + width;
+                const se = ne + width;
+                const a = kind[nw];
+                const b = kind[ne];
+                if (a === b || kind[se] !== a || kind[sw] !== b)
+                    continue;
+                // The kind that survives: land over lake over sea; the other diagonal gives way.
+                const rank = (value) => value === PARTITION_KIND.land ? 2 : value === PARTITION_KIND.lake ? 0 : 1;
+                const keep = rank(a) >= rank(b) ? a : b;
+                const target = keep === a ? ne : nw;
+                kind[target] = keep;
+                changed.push(target);
+                found = true;
+            }
+        }
+        if (!found)
+            break;
+    }
+    return changed;
+}
+/**
+ * Province parts never join across the east-west seam, so a 2x2 window that straddles it holds
+ * four provinces whenever the kind changes vertically on both sides (a coast that crosses the
+ * seam). Make the east column (x = 0) agree with its upper pixel there, one pixel per crossing,
+ * and return the changed pixels.
+ */
+export function repairSeamCorners(kind, width, height, maxPasses = 8) {
+    const changed = [];
+    if (width < 2)
+        return changed;
+    for (let pass = 0; pass < maxPasses; pass++) {
+        let found = false;
+        for (let y = 0; y + 1 < height; y++) {
+            const west = y * width + width - 1;
+            const east = y * width;
+            if (kind[west] === kind[west + width] || kind[east] === kind[east + width])
+                continue;
+            kind[east + width] = kind[east];
+            changed.push(east + width);
+            found = true;
+        }
+        if (!found)
+            break;
+    }
+    return changed;
+}
+// ---------------------------------------------------------------------------------------------
+// Adapter from bitmaps
+/**
+ * Terrain class of each graphical terrain index of the base game's `terrain.bmp`: 0 plains,
+ * 1 forest, 2 and 17 hills, 3 desert, 4 sparse forest, 5 farmland, 6, 16 and 20 mountain, 9 marsh,
+ * 13 urban, 15 ocean, 19 permanent snow, 21 and 22 jungle. Others are plains. A mod with other
+ * indices passes its own table (the border metric derives one from `common/terrain`).
+ */
+export function defaultTerrainClassTable() {
+    const table = new Uint8Array(256).fill(PARTITION_TERRAIN.plains);
+    const set = (name, ...indices) => {
+        for (const index of indices)
+            table[index] = PARTITION_TERRAIN[name];
+    };
+    set('forest', 1, 4);
+    set('hills', 2, 17);
+    set('desert', 3);
+    set('farmland', 5);
+    set('mountain', 6, 16, 20);
+    set('marsh', 9);
+    set('urban', 13);
+    set('water', 15, 14);
+    set('snow', 19);
+    set('jungle', 21, 22);
+    return table;
+}
+/** Three-four chamfer distance in pixels (capped at 255) to the nearest pixel of `source`. */
+export function chamferDistance(source, width, height) {
+    const cap = 255 * 3;
+    const distance = new Uint16Array(width * height);
+    let any = false;
+    for (let p = 0; p < distance.length; p++) {
+        if (source(p)) {
+            distance[p] = 0;
+            any = true;
+        }
+        else
+            distance[p] = cap;
+    }
+    const output = new Uint8Array(width * height);
+    if (!any) {
+        output.fill(255);
+        return output;
+    }
+    // The east-west seam wraps, so two sweeps of both directions reach every pixel.
+    for (let sweep = 0; sweep < 2; sweep++) {
+        for (let y = 0; y < height; y++) {
+            const row = y * width;
+            for (let x = 0; x < width; x++) {
+                const left = x === 0 ? width - 1 : x - 1;
+                const right = x === width - 1 ? 0 : x + 1;
+                let best = distance[row + x];
+                const west = distance[row + left] + 3;
+                if (west < best)
+                    best = west;
+                if (y > 0) {
+                    const above = row - width;
+                    const n = distance[above + x] + 3;
+                    const nw = distance[above + left] + 4;
+                    const ne = distance[above + right] + 4;
+                    if (n < best)
+                        best = n;
+                    if (nw < best)
+                        best = nw;
+                    if (ne < best)
+                        best = ne;
+                }
+                distance[row + x] = best > cap ? cap : best;
+            }
+        }
+        for (let y = height - 1; y >= 0; y--) {
+            const row = y * width;
+            for (let x = width - 1; x >= 0; x--) {
+                const left = x === 0 ? width - 1 : x - 1;
+                const right = x === width - 1 ? 0 : x + 1;
+                let best = distance[row + x];
+                const east = distance[row + right] + 3;
+                if (east < best)
+                    best = east;
+                if (y < height - 1) {
+                    const below = row + width;
+                    const s = distance[below + x] + 3;
+                    const sw = distance[below + left] + 4;
+                    const se = distance[below + right] + 4;
+                    if (s < best)
+                        best = s;
+                    if (sw < best)
+                        best = sw;
+                    if (se < best)
+                        best = se;
+                }
+                distance[row + x] = best > cap ? cap : best;
+            }
+        }
+    }
+    for (let p = 0; p < output.length; p++) {
+        const value = distance[p];
+        output[p] = value >= cap ? 255 : Math.min(254, Math.floor((value + 1) / 3));
+    }
+    return output;
+}
+/** Central-difference gradient magnitude times 16, clamped to 255; zero off land. */
+export function slopeField(heights, kind, width, height) {
+    const output = new Uint8Array(width * height);
+    for (let y = 0; y < height; y++) {
+        const row = y * width;
+        const above = (y > 0 ? y - 1 : y) * width;
+        const below = (y < height - 1 ? y + 1 : y) * width;
+        for (let x = 0; x < width; x++) {
+            if (kind[row + x] !== PARTITION_KIND.land)
+                continue;
+            const left = x === 0 ? width - 1 : x - 1;
+            const right = x === width - 1 ? 0 : x + 1;
+            // The step down to the water is not a slope: a neighbour that is not land counts as level.
+            const here = heights[row + x];
+            const hl = kind[row + left] === PARTITION_KIND.land ? heights[row + left] : here;
+            const hr = kind[row + right] === PARTITION_KIND.land ? heights[row + right] : here;
+            const ha = kind[above + x] === PARTITION_KIND.land ? heights[above + x] : here;
+            const hb = kind[below + x] === PARTITION_KIND.land ? heights[below + x] : here;
+            const dx = hr - hl;
+            const dy = hb - ha;
+            // |gradient| = sqrt(dx^2 + dy^2) / 2 per pixel; times 16.
+            const value = Math.sqrt(dx * dx + dy * dy) * 8;
+            output[row + x] = value > 255 ? 255 : Math.round(value);
+        }
+    }
+    return output;
+}
+/**
+ * Ridge strength: how far a land pixel stands above the mean of its two neighbours three pixels
+ * away along the best of four axes, times 10. A crest line is a band a few pixels wide.
+ */
+export function ridgeField(heights, kind, width, height, reach = 3) {
+    const output = new Uint8Array(width * height);
+    const axes = [
+        [1, 0],
+        [0, 1],
+        [1, 1],
+        [1, -1],
+    ];
+    for (let y = 0; y < height; y++) {
+        const row = y * width;
+        for (let x = 0; x < width; x++) {
+            const p = row + x;
+            if (kind[p] !== PARTITION_KIND.land)
+                continue;
+            const here = heights[p];
+            let best = 0;
+            for (const [ax, ay] of axes) {
+                const y0 = y - ay * reach;
+                const y1 = y + ay * reach;
+                if (y0 < 0 || y1 >= height || y0 >= height || y1 < 0)
+                    continue;
+                const x0 = (((x - ax * reach) % width) + width) % width;
+                const x1 = (x + ax * reach) % width;
+                const p0 = y0 * width + x0;
+                const p1 = y1 * width + x1;
+                // Water at either end is no valley: it counts as level ground.
+                const h0 = kind[p0] === PARTITION_KIND.land ? heights[p0] : here;
+                const h1 = kind[p1] === PARTITION_KIND.land ? heights[p1] : here;
+                const lift = here - (h0 + h1) / 2;
+                if (lift > best)
+                    best = lift;
+            }
+            const value = best * 10;
+            output[p] = value > 255 ? 255 : Math.round(value);
+        }
+    }
+    return output;
+}
+const FERTILITY_BASE = {
+    [PARTITION_TERRAIN.plains]: 150,
+    [PARTITION_TERRAIN.farmland]: 225,
+    [PARTITION_TERRAIN.forest]: 110,
+    [PARTITION_TERRAIN.hills]: 85,
+    [PARTITION_TERRAIN.mountain]: 20,
+    [PARTITION_TERRAIN.desert]: 25,
+    [PARTITION_TERRAIN.marsh]: 70,
+    [PARTITION_TERRAIN.jungle]: 95,
+    [PARTITION_TERRAIN.snow]: 5,
+    [PARTITION_TERRAIN.urban]: 140,
+};
+/**
+ * Fertility from terrain class, river proximity (valleys are rich), slope and optional moisture.
+ * The relief and climate stages replace it with their own field; the partition only reads bytes.
+ */
+export function fertilityField(kind, terrainClass, riverDistance, slope, moisture) {
+    const output = new Uint8Array(kind.length);
+    for (let p = 0; p < kind.length; p++) {
+        if (kind[p] !== PARTITION_KIND.land)
+            continue;
+        let value = FERTILITY_BASE[terrainClass[p]] ?? 100;
+        const river = riverDistance[p];
+        if (river <= 14)
+            value += (14 - river) * 4;
+        value -= slope[p] * 0.5;
+        if (moisture !== undefined)
+            value += (moisture[p] - 128) * 0.25;
+        output[p] = value < 0 ? 0 : value > 255 ? 255 : Math.round(value);
+    }
+    return output;
+}
+/** Compute the partition fields from the bitmaps a map already has. */
+export function partitionFieldsFromBitmaps(input) {
+    const { width, height, kind } = input;
+    const total = width * height;
+    const riverMax = input.riverMaxIndex ?? 11;
+    const rivers = input.rivers;
+    const riverDistance = rivers === undefined
+        ? new Uint8Array(total).fill(255)
+        : chamferDistance((p) => rivers[p] <= riverMax && kind[p] === PARTITION_KIND.land, width, height);
+    const slope = input.heights === undefined
+        ? new Uint8Array(total)
+        : slopeField(input.heights, kind, width, height);
+    const ridge = input.heights === undefined
+        ? new Uint8Array(total)
+        : ridgeField(input.heights, kind, width, height);
+    const terrainClass = new Uint8Array(total).fill(PARTITION_TERRAIN.water);
+    const table = input.terrainClasses ?? defaultTerrainClassTable();
+    for (let p = 0; p < total; p++)
+        if (kind[p] === PARTITION_KIND.land)
+            terrainClass[p] =
+                input.terrain === undefined ? PARTITION_TERRAIN.plains : table[input.terrain[p]];
+    for (let p = 0; p < total; p++)
+        if (kind[p] === PARTITION_KIND.land && terrainClass[p] === PARTITION_TERRAIN.water)
+            terrainClass[p] = PARTITION_TERRAIN.plains;
+    return {
+        width,
+        height,
+        kind,
+        riverDistance,
+        ridge,
+        slope,
+        terrainClass,
+        regionId: input.regionId ?? new Uint16Array(total),
+        fertility: fertilityField(kind, terrainClass, riverDistance, slope, input.moisture),
+        barrier: input.barrier ?? new Uint8Array(total),
+        ...(input.regions === undefined ? {} : { regions: input.regions }),
+    };
+}