hoi4-agent-tools 4.3.0 → 4.5.0

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 }),
+    };
+}

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

@@ -0,0 +1,113 @@
+import { ServiceError } from '../core/result.js';
+import { forEachPolylinePixel, rowStrips, scanAreaStrip, } from './geography/index.js';
+import { PARTITION_KIND } from './partition-fields.js';
+import { BARRIER_CREST, BARRIER_FORT_LINE, BARRIER_WALL, } from './relief/fields.js';
+/**
+ * Geography inputs of the partition (ADR 0058): the named regions and seas of the model become the
+ * `regionId` plane and the region table (with the density each asks for), and every range that
+ * declares itself a wall or an impassable barrier becomes a barrier line no province may straddle.
+ * Relief, rivers, fertility and terrain classes stay as the caller computed them.
+ */
+/** Pixels written by one range path per side: three pixels wide, so no 4-connected path crosses. */
+const WALL_HALF_WIDTH = 1;
+/**
+ * Return `fields` with `regionId`, `regions` and `barrier` taken from the resolved geography.
+ * Land regions are written on land pixels and named seas on sea pixels, so a lake is never part
+ * of a region by itself. Overlapping areas resolve in id order, later ids winning; ids are the
+ * 1-based position in the sorted list of regions that have an area, followed by the seas.
+ */
+export function partitionFieldsFromGeography(fields, geography, options = {}) {
+    const { width, height, kind } = fields;
+    const grid = { width, height };
+    const regionId = new Uint16Array(fields.regionId);
+    const barrier = new Uint8Array(fields.barrier);
+    const table = [];
+    const areas = [];
+    const seaAreas = [];
+    let next = 1;
+    for (const region of geography.regions) {
+        if (region.area === undefined)
+            continue;
+        const entry = { id: next, kind: 'land' };
+        if (region.name !== undefined)
+            entry.name = region.name;
+        if (region.provinceAreaPx !== undefined)
+            entry.provinceAreaPx = region.provinceAreaPx;
+        if (region.provincesPerState !== undefined)
+            entry.provincesPerState = region.provincesPerState;
+        table.push(entry);
+        areas.push({ id: next, area: region.area });
+        next += 1;
+    }
+    for (const sea of geography.seas) {
+        if (next > 65_535)
+            break;
+        const entry = { id: next, kind: 'sea' };
+        if (sea.name !== undefined)
+            entry.name = sea.name;
+        table.push(entry);
+        seaAreas.push({ id: next, area: sea.area });
+        next += 1;
+    }
+    for (const strip of rowStrips(grid, options.stripRows ?? 256)) {
+        for (const { id, area } of areas)
+            scanAreaStrip(area, grid, strip, (y, x0, x1) => {
+                const row = y * width;
+                for (let x = x0; x < x1; x++)
+                    if (kind[row + x] === PARTITION_KIND.land)
+                        regionId[row + x] = id;
+            });
+        for (const { id, area } of seaAreas)
+            scanAreaStrip(area, grid, strip, (y, x0, x1) => {
+                const row = y * width;
+                for (let x = x0; x < x1; x++)
+                    if (kind[row + x] === PARTITION_KIND.sea)
+                        regionId[row + x] = id;
+            });
+    }
+    const whole = { y0: 0, y1: height };
+    for (const range of geography.ranges) {
+        if (range.profile !== 'wall' && range.barrier !== 'impassable')
+            continue;
+        forEachPolylinePixel(range.path, grid, whole, (x, y) => {
+            for (let dy = -WALL_HALF_WIDTH; dy <= WALL_HALF_WIDTH; dy++)
+                for (let dx = -WALL_HALF_WIDTH; dx <= WALL_HALF_WIDTH; dx++) {
+                    if (Math.abs(dx) + Math.abs(dy) > WALL_HALF_WIDTH)
+                        continue;
+                    const yy = y + dy;
+                    if (yy < 0 || yy >= height)
+                        continue;
+                    barrier[yy * width + ((x + dx + width) % width)] = 255;
+                }
+        });
+    }
+    return { ...fields, regionId, barrier, regions: table };
+}
+/** Strength each model-drawn line of the terrain synthesis gives the partition's barrier plane. */
+const TERRAIN_LINE_STRENGTH = [
+    [BARRIER_WALL, 255],
+    [BARRIER_FORT_LINE, 180],
+    [BARRIER_CREST, 150],
+];
+/**
+ * Return `fields` with the lines the terrain synthesis drew from the model (ADR 0056) raised in
+ * its `barrier` plane: a wall outside its pass gaps at 255 (a hard line no province straddles), a
+ * fort line at 180 and a range crest at 150. Rivers and steep ground are left to the
+ * `riverDistance`, `slope` and `ridge` planes, which already carry them, so they do not count
+ * twice. A stronger value already in the plane is kept.
+ */
+export function partitionFieldsWithTerrainLines(fields, lines) {
+    const { width, height } = fields;
+    if (lines.width !== width || lines.height !== height)
+        throw new ServiceError('MAP_PARTITION_FIELDS_INVALID', 'The terrain barrier field does not match the partition dimensions', { width, height, barrier: { width: lines.width, height: lines.height } });
+    const barrier = new Uint8Array(fields.barrier);
+    for (let p = 0; p < barrier.length; p++) {
+        const sources = lines.sources[p];
+        if (sources === 0)
+            continue;
+        for (const [flag, strength] of TERRAIN_LINE_STRENGTH)
+            if ((sources & flag) !== 0 && strength > barrier[p])
+                barrier[p] = strength;
+    }
+    return { ...fields, barrier };
+}

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

@@ -0,0 +1,165 @@
+import { ServiceError } from '../core/result.js';
+/** Build the weighted graph in one pass over the province raster. */
+export function buildProvinceGraph(input) {
+    const { width, height, pixel, barrier } = input;
+    const count = input.kind.length;
+    if (pixel.length !== width * height)
+        throw new ServiceError('MAP_PARTITION_GRAPH_INVALID', 'The province raster does not match the map dimensions');
+    if (barrier !== undefined && barrier.length !== pixel.length)
+        throw new ServiceError('MAP_PARTITION_GRAPH_INVALID', 'The barrier plane does not match the map dimensions');
+    const index = new Map();
+    let capacity = 1 << 14;
+    let lengthList = new Uint32Array(capacity);
+    let sumList = new Float64Array(capacity);
+    let fromList = new Int32Array(capacity);
+    let toList = new Int32Array(capacity);
+    let edges = 0;
+    const add = (a, b, strength) => {
+        const low = a < b ? a : b;
+        const high = a < b ? b : a;
+        const key = low * 65_536 + high;
+        let slot = index.get(key);
+        if (slot === undefined) {
+            slot = edges++;
+            if (slot === capacity) {
+                capacity *= 2;
+                const l = new Uint32Array(capacity);
+                l.set(lengthList);
+                lengthList = l;
+                const s = new Float64Array(capacity);
+                s.set(sumList);
+                sumList = s;
+                const f = new Int32Array(capacity);
+                f.set(fromList);
+                fromList = f;
+                const t = new Int32Array(capacity);
+                t.set(toList);
+                toList = t;
+            }
+            fromList[slot] = low;
+            toList[slot] = high;
+            index.set(key, slot);
+        }
+        lengthList[slot]++;
+        sumList[slot] += strength;
+    };
+    if (count > 65_535)
+        throw new ServiceError('MAP_PARTITION_GRAPH_INVALID', 'The graph supports 65,535 provinces');
+    for (let y = 0; y < height; y++) {
+        const row = y * width;
+        for (let x = 0; x < width; x++) {
+            const p = row + x;
+            const id = pixel[p];
+            const east = x + 1 < width ? p + 1 : row;
+            const other = pixel[east];
+            if (other !== id)
+                add(id, other, barrier === undefined ? 0 : Math.max(barrier[p], barrier[east]));
+            if (y + 1 < height) {
+                const south = p + width;
+                const below = pixel[south];
+                if (below !== id)
+                    add(id, below, barrier === undefined ? 0 : Math.max(barrier[p], barrier[south]));
+            }
+        }
+    }
+    const degree = new Int32Array(count + 1);
+    for (let e = 0; e < edges; e++) {
+        degree[fromList[e] + 1]++;
+        degree[toList[e] + 1]++;
+    }
+    for (let i = 0; i < count; i++)
+        degree[i + 1] += degree[i];
+    const offsets = degree;
+    const cursor = Int32Array.from(offsets.subarray(0, count));
+    const to = new Int32Array(offsets[count]);
+    const length = new Uint32Array(offsets[count]);
+    const mean = new Float32Array(offsets[count]);
+    // Edges sorted by (low, high) keep every row ascending without a second sort.
+    const order = Array.from({ length: edges }, (_, i) => i).sort((a, b) => fromList[a] - fromList[b] || toList[a] - toList[b]);
+    for (const e of order) {
+        const a = fromList[e];
+        const b = toList[e];
+        const strength = sumList[e] / lengthList[e] / 255;
+        to[cursor[a]] = b;
+        length[cursor[a]] = lengthList[e];
+        mean[cursor[a]++] = strength;
+    }
+    for (const e of order) {
+        const a = fromList[e];
+        const b = toList[e];
+        const strength = sumList[e] / lengthList[e] / 255;
+        to[cursor[b]] = a;
+        length[cursor[b]] = lengthList[e];
+        mean[cursor[b]++] = strength;
+    }
+    // Rows now hold the high-numbered neighbours of each province, then the low-numbered ones.
+    sortRows(offsets, to, length, mean);
+    const kind = Uint8Array.from({ length: count }, (_, i) => input.kind[i]);
+    const size = Uint32Array.from({ length: count }, (_, i) => input.size[i]);
+    const centerX = new Float32Array(count);
+    const centerY = new Float32Array(count);
+    for (let i = 0; i < count; i++) {
+        const n = Math.max(1, size[i]);
+        centerX[i] = input.sumX[i] / n;
+        centerY[i] = input.sumY[i] / n;
+    }
+    return {
+        count,
+        kind,
+        offsets,
+        to,
+        length,
+        barrier: mean,
+        centerX,
+        centerY,
+        width,
+        height,
+        size,
+    };
+}
+function sortRows(offsets, to, length, barrier) {
+    for (let row = 0; row + 1 < offsets.length; row++) {
+        const start = offsets[row];
+        const end = offsets[row + 1];
+        // Insertion sort: rows hold a handful of neighbours.
+        for (let i = start + 1; i < end; i++) {
+            const t = to[i];
+            const l = length[i];
+            const b = barrier[i];
+            let j = i - 1;
+            while (j >= start && to[j] > t) {
+                to[j + 1] = to[j];
+                length[j + 1] = length[j];
+                barrier[j + 1] = barrier[j];
+                j--;
+            }
+            to[j + 1] = t;
+            length[j + 1] = l;
+            barrier[j + 1] = b;
+        }
+    }
+}
+/**
+ * Directed edge costs for growing territory over the graph: centroid distance (across the seam
+ * when shorter) times `1 + barrier * strength`, aligned with `graph.to`. Territory assignment
+ * runs its Dijkstra on these and may add its own terms.
+ */
+export function provinceEdgeCosts(graph, options = {}) {
+    const beta = options.barrier ?? 6;
+    const water = options.water ?? 3;
+    const cost = new Float32Array(graph.to.length);
+    for (let a = 0; a < graph.count; a++)
+        for (let e = graph.offsets[a]; e < graph.offsets[a + 1]; e++) {
+            const b = graph.to[e];
+            let dx = graph.centerX[a] - graph.centerX[b];
+            if (dx > graph.width / 2)
+                dx -= graph.width;
+            else if (dx < -graph.width / 2)
+                dx += graph.width;
+            const dy = graph.centerY[a] - graph.centerY[b];
+            const distance = Math.sqrt(dx * dx + dy * dy);
+            cost[e] =
+                distance * (1 + beta * graph.barrier[e]) * (graph.kind[a] === graph.kind[b] ? 1 : water);
+        }
+    return cost;
+}