hoi4-agent-tools 4.5.0 → 4.6.1

package/dist/hoi4_agent_tools/map/state-restructure.js

@@ -0,0 +1,378 @@
+import { compareCodeUnits } from '../core/canonical.js';
+import { ServiceError } from '../core/result.js';
+import { assignments, encodeSource, parseLocalisation } from '../core/source/index.js';
+import { parseMapDate } from './model.js';
+import { addChange, appendLocalisationEntry, applyTextRanges, assertDatedStateHistorySafe, buildingPositionLine, cloneState, commitState, compileState, currentIndex, escapedLocalisationValue, isLevelStateBuilding, localisationEntryLine, maximumObservedId, normalizeRelative, regionMembershipId, removalContent, remapScriptReferences, requireSafeLocalisationDocument, rootEvidence, uniqueStrings, } from './operations.js';
+/**
+ * Split `total` into whole shares proportional to `weights` so the parts add up exactly. Integers
+ * use the largest-remainder rule; a value with decimals is shared in hundredths.
+ */
+export function apportion(total, weights) {
+    const scale = Number.isInteger(total) ? 1 : 100;
+    const units = Math.round(total * scale);
+    const sum = weights.reduce((acc, weight) => acc + weight, 0);
+    if (weights.length === 0)
+        return [];
+    if (sum <= 0) {
+        const shares = weights.map(() => 0);
+        shares[0] = units;
+        return shares.map((share) => share / scale);
+    }
+    const raw = weights.map((weight) => (units * weight) / sum);
+    const shares = raw.map((value) => Math.floor(value));
+    let remaining = units - shares.reduce((acc, share) => acc + share, 0);
+    const order = raw
+        .map((value, index) => ({ index, remainder: value - Math.floor(value) }))
+        .sort((left, right) => right.remainder - left.remainder || left.index - right.index);
+    for (let position = 0; remaining > 0 && order.length > 0; position += 1, remaining -= 1)
+        shares[order[position % order.length].index] += 1;
+    return shares.map((share) => share / scale);
+}
+function statesOfGroups(index, groups) {
+    const owner = new Map();
+    const seen = new Map();
+    for (const [position, group] of groups.entries()) {
+        if (group.provinces.length === 0)
+            throw new ServiceError('MAP_STATE_WOULD_BE_EMPTY', `State group ${position} has no provinces`);
+        for (const province of group.provinces) {
+            if (seen.has(province))
+                throw new ServiceError('MAP_STATE_PROVINCE_SELECTION_INVALID', `Province ${province} appears in state groups ${seen.get(province)} and ${position}`, { province });
+            seen.set(province, position);
+            const states = index.stateForProvince(province);
+            if (states.length !== 1)
+                throw new ServiceError('MAP_STATE_MEMBERSHIP_AMBIGUOUS', `Province ${province} must belong to exactly one state to be regrouped`, { province, states: states.map(({ id }) => id) });
+            owner.set(province, states[0]);
+        }
+    }
+    return { stateOfProvince: owner, groupOfProvince: seen };
+}
+/** Rewrite the state files so that exactly `groups` hold the provinces of the states they touch. */
+export function restructureStates(base, changes, allocations, groups, options) {
+    const index = currentIndex(base, changes);
+    const operationId = options.operationId;
+    const { stateOfProvince, groupOfProvince } = statesOfGroups(index, groups);
+    const affected = new Map();
+    for (const state of stateOfProvince.values())
+        affected.set(state.id, state);
+    if (affected.size === 0)
+        return { changed: [], created: [], removed: [], heirs: [], stateIds: [] };
+    // The groups must cover every province of every state they touch.
+    for (const state of affected.values())
+        for (const province of state.provinces)
+            if (!groupOfProvince.has(province))
+                throw new ServiceError('MAP_STATE_RESTRUCTURE_INCOMPLETE', `State ${state.id} would lose province ${province} to no state; every province of a regrouped state needs a group`, { stateId: state.id, province });
+    const pixels = (province) => index.raster?.geometry.get(province)?.pixelCount ?? 0;
+    // Pixel overlap of every group with every old state.
+    const overlap = groups.map(() => new Map());
+    const stateTotals = new Map();
+    for (const [position, group] of groups.entries())
+        for (const province of group.provinces) {
+            const state = stateOfProvince.get(province);
+            const size = pixels(province);
+            overlap[position].set(state.id, (overlap[position].get(state.id) ?? 0) + size);
+        }
+    for (const state of affected.values())
+        stateTotals.set(state.id, state.provinces.reduce((sum, province) => sum + pixels(province), 0));
+    for (const [stateId, total] of stateTotals)
+        if (total <= 0)
+            throw new ServiceError('MAP_STATE_DISTRIBUTION_GEOMETRY_MISSING', `State ${stateId} has no province geometry; proportional distribution needs the province map`, { stateId });
+    // Heirs: the biggest overlaps first; ties go to the lower state id and group index.
+    const pairs = [];
+    for (const [position, map] of overlap.entries())
+        for (const [state, px] of map)
+            pairs.push({ group: position, state, pixels: px });
+    pairs.sort((a, b) => b.pixels - a.pixels || a.state - b.state || a.group - b.group);
+    const heirOfGroup = new Map();
+    const groupOfHeir = new Map();
+    for (const pair of pairs) {
+        if (heirOfGroup.has(pair.group) || groupOfHeir.has(pair.state))
+            continue;
+        heirOfGroup.set(pair.group, pair.state);
+        groupOfHeir.set(pair.state, pair.group);
+    }
+    // A group takes provinces of one strategic region only.
+    for (const [position, group] of groups.entries()) {
+        const regions = new Set(group.provinces.map((province) => regionMembershipId(index, province)));
+        if (regions.size > 1)
+            throw new ServiceError('MAP_STATE_REGION_DISTRIBUTION_CONFLICT', `State group ${position} (provinces ${group.provinces.slice(0, 6).join(', ')}...) spans strategic regions ${[...regions].join(', ')}; a state may hold provinces of one region only`, { group: position, regions: [...regions] });
+    }
+    // Dated history cannot follow a regrouping safely.
+    const removedStates = [...affected.values()].filter((state) => !groupOfHeir.has(state.id));
+    for (const state of removedStates) {
+        const dated = state.historyBlock === undefined
+            ? undefined
+            : assignments(state.historyBlock).find((entry) => entry.value.type === 'block' && parseMapDate(entry.key.value) !== undefined);
+        if (dated !== undefined)
+            throw new ServiceError('MAP_DATED_STATE_HISTORY_CONFLICT', `State ${state.id} has dated history (${dated.key.value}) that would be lost when its provinces move to other states; edit or move that block first`, { stateId: state.id, datedAt: dated.key.value, sourcePath: state.file.displayPath });
+    }
+    // Allocate identifiers for groups with no heir: the lowest positive ids no root uses.
+    const used = new Set(index.statesAcrossRoots.map(({ id }) => id));
+    const highest = maximumObservedId(index.statesAcrossRoots.map(({ id }) => id), 0);
+    const roots = rootEvidence(index.statesAcrossRoots.map(({ id, file }) => ({ id, file })));
+    const stateIds = [];
+    let cursor = 1;
+    let probes = 0;
+    for (const position of groups.keys()) {
+        const heir = heirOfGroup.get(position);
+        if (heir !== undefined) {
+            stateIds.push(heir);
+            continue;
+        }
+        while (used.has(cursor)) {
+            cursor += 1;
+            probes += 1;
+        }
+        if (cursor >= 2_147_483_647)
+            throw new ServiceError('MAP_STATE_ID_EXHAUSTED', 'No safe state ID remains available');
+        used.add(cursor);
+        stateIds.push(cursor);
+        allocations.push({
+            kind: 'state-id',
+            allocated: cursor,
+            strategy: 'lowest-positive-unused-active-id-across-roots',
+            highestObserved: highest,
+            probes: probes + 1,
+            roots,
+        });
+    }
+    const contributions = groups.map(() => new Map());
+    for (const state of affected.values()) {
+        const takers = groups.flatMap((_, position) => overlap[position].has(state.id) ? [position] : []);
+        const weights = takers.map((position) => overlap[position].get(state.id));
+        const manpower = apportion(state.manpower, weights);
+        const resourceShares = new Map();
+        for (const [resource, amount] of state.resources)
+            resourceShares.set(resource, apportion(amount, weights));
+        const buildingShares = new Map();
+        for (const [building, amount] of state.stateBuildings)
+            buildingShares.set(building, isLevelStateBuilding(index, building) ? 'level' : apportion(amount, weights));
+        for (const [slot, position] of takers.entries()) {
+            const resources = new Map();
+            for (const [resource, shares] of resourceShares)
+                if (shares[slot] !== 0)
+                    resources.set(resource, shares[slot]);
+            const buildings = new Map();
+            for (const [building, shares] of buildingShares) {
+                const value = shares === 'level' ? state.stateBuildings.get(building) : shares[slot];
+                if (value !== 0)
+                    buildings.set(building, value);
+            }
+            contributions[position].set(state.id, { manpower: manpower[slot], resources, buildings });
+        }
+    }
+    // Ownership fields written for a group, and whether they differ from the heir's.
+    const sameList = (left, right) => left.length === right.length && left.every((value, position) => value === right[position]);
+    const changed = [];
+    const created = [];
+    const names = [];
+    const nameCounts = new Map();
+    const provinceState = new Map();
+    const statesRoot = index.sourceRoots.states[0] ?? 'history/states';
+    const reservedFiles = new Set();
+    for (const [position, group] of groups.entries()) {
+        const heirId = heirOfGroup.get(position);
+        const parts = [...contributions[position].keys()].sort((a, b) => a - b);
+        const sources = parts.map((id) => affected.get(id));
+        const primaryId = heirId ?? [...overlap[position]].sort((a, b) => b[1] - a[1] || a[0] - b[0])[0][0];
+        const primary = affected.get(primaryId);
+        const provinces = [...group.provinces].sort((a, b) => a - b);
+        const set = new Set(provinces);
+        const data = cloneState(primary);
+        data.provinces = provinces;
+        data.manpower = 0;
+        data.resources = new Map();
+        data.stateBuildings = new Map();
+        for (const id of parts) {
+            const part = contributions[position].get(id);
+            data.manpower += part.manpower;
+            for (const [resource, amount] of part.resources)
+                data.resources.set(resource, (data.resources.get(resource) ?? 0) + amount);
+            for (const [building, amount] of part.buildings)
+                data.stateBuildings.set(building, isLevelStateBuilding(index, building)
+                    ? Math.max(data.stateBuildings.get(building) ?? 0, amount)
+                    : (data.stateBuildings.get(building) ?? 0) + amount);
+        }
+        for (const [resource, amount] of data.resources)
+            data.resources.set(resource, Math.round(amount * 100) / 100);
+        data.victoryPoints = sources.flatMap((state) => state.victoryPoints
+            .filter(({ provinceId }) => set.has(provinceId))
+            .map(({ provinceId, value }) => ({ provinceId, value })));
+        data.provinceBuildings = new Map(sources.flatMap((state) => [...state.provinceBuildings]
+            .filter(([provinceId]) => set.has(provinceId))
+            .map(([provinceId, values]) => [provinceId, new Map(values)])));
+        data.cores = uniqueStrings(sources.flatMap((state) => state.cores));
+        data.claims = uniqueStrings(sources.flatMap((state) => state.claims));
+        if (group.cores !== undefined)
+            data.cores = uniqueStrings(group.cores);
+        if (group.claims !== undefined)
+            data.claims = uniqueStrings(group.claims);
+        if (group.addCores !== undefined)
+            data.cores = uniqueStrings([...data.cores, ...group.addCores]);
+        if (group.addClaims !== undefined)
+            data.claims = uniqueStrings([...data.claims, ...group.addClaims]);
+        if (group.owner !== undefined)
+            data.owner = group.owner ?? undefined;
+        if (group.controller !== undefined)
+            data.controller = group.controller ?? undefined;
+        const finalId = stateIds[position];
+        for (const province of provinces)
+            provinceState.set(province, finalId);
+        if (heirId !== undefined) {
+            const heir = affected.get(heirId);
+            const fields = {
+                manpower: true,
+                resources: true,
+                provinces: true,
+                victoryPoints: true,
+                buildings: true,
+            };
+            if (!sameList(data.cores, uniqueStrings(heir.cores)))
+                fields.cores = true;
+            if (!sameList(data.claims, uniqueStrings(heir.claims)))
+                fields.claims = true;
+            if (data.owner !== heir.owner)
+                fields.owner = true;
+            if (data.controller !== heir.controller)
+                fields.controller = true;
+            commitState(changes, heir, data, fields, operationId);
+            changed.push(heirId);
+            continue;
+        }
+        // A new state: the largest source's history, with its undated blocks, under a new identifier.
+        assertDatedStateHistorySafe(primary, { provinces: true }, operationId);
+        const dated = [];
+        if (primary.historyBlock !== undefined)
+            for (const entry of assignments(primary.historyBlock))
+                if (entry.value.type === 'block' && parseMapDate(entry.key.value) !== undefined)
+                    dated.push(primary.document.text.slice(entry.start, entry.end));
+        data.id = finalId;
+        data.name = `STATE_${finalId}`;
+        data.datedHistory = dated;
+        let relativePath = `${statesRoot}/${finalId}-AGENT_STATE.txt`;
+        for (let suffix = 2;; suffix += 1) {
+            const key = normalizeRelative(relativePath);
+            if (!index.activeFiles.byRelativePath.has(key) && !reservedFiles.has(key))
+                break;
+            relativePath = `${statesRoot}/${finalId}-AGENT_STATE_${suffix}.txt`;
+        }
+        reservedFiles.add(normalizeRelative(relativePath));
+        addChange(changes, relativePath, compileState(data, primary.document.newline), operationId, 'text/plain');
+        created.push(finalId);
+        const label = index.localisationByKey.get(`l_english:${primary.name}`)?.[0]?.entry.value ??
+            `State ${primary.id}`;
+        const ordinal = (nameCounts.get(primary.id) ?? 1) + 1;
+        nameCounts.set(primary.id, ordinal);
+        names.push([`STATE_${finalId}`, `${label} (${ordinal})`]);
+    }
+    // Dated history of a heir that loses land is refused by `commitState` above; removed states go.
+    for (const state of removedStates)
+        addChange(changes, state.file.relativePath, removalContent(index, state.file, `State ${state.id} regrouped into other states`), operationId, 'text/plain');
+    remapPositions(index, changes, provinceState, operationId);
+    upsertStateNames(index, changes, names, operationId);
+    if (options.remapReferences !== undefined) {
+        const mapping = [];
+        for (const state of affected.values()) {
+            const takers = groups.flatMap((_, position) => overlap[position].has(state.id) ? [position] : []);
+            const targets = [...new Set(takers.map((position) => stateIds[position]))];
+            const heirGroup = groupOfHeir.get(state.id);
+            const keepsId = heirGroup !== undefined;
+            const others = targets.filter((id) => id !== state.id);
+            if (keepsId && others.length === 0)
+                continue;
+            mapping.push({
+                from: state.id,
+                to: keepsId
+                    ? [state.id, ...others]
+                    : takers.length === 1
+                        ? stateIds[takers[0]]
+                        : (() => {
+                            const best = takers
+                                .slice()
+                                .sort((a, b) => overlap[b].get(state.id) - overlap[a].get(state.id) || a - b)[0];
+                            return [stateIds[best], ...targets.filter((id) => id !== stateIds[best])];
+                        })(),
+            });
+        }
+        if (mapping.length > 0)
+            remapScriptReferences(base, changes, operationId, {
+                entity: 'state',
+                mapping,
+                readOnlySources: options.remapReferences,
+            });
+    }
+    return {
+        changed: changed.sort((a, b) => a - b),
+        created,
+        removed: removedStates.map(({ id }) => id).sort((a, b) => a - b),
+        heirs: [...groupOfHeir]
+            .map(([stateId, group]) => ({ stateId, group }))
+            .sort((a, b) => a.stateId - b.stateId),
+        stateIds,
+    };
+}
+/** Point every building position at the state that now holds the province it lies in. */
+function remapPositions(index, changes, provinceState, operationId) {
+    const documents = new Map(index.buildingPositions.map((record) => [record.document.file.relativePath, record.document]));
+    for (const [relativePath, document] of documents) {
+        const replacements = index.buildingPositions
+            .filter((record) => record.document === document)
+            .flatMap((record) => {
+            const provinceId = index.provinceAtMapCoordinate(record.x, record.z);
+            const target = provinceId === undefined ? undefined : provinceState.get(provinceId);
+            if (target === undefined || target === record.stateId)
+                return [];
+            const line = document.lines[record.line - 1];
+            return line === undefined
+                ? []
+                : [
+                    {
+                        start: line.start,
+                        end: line.end,
+                        text: buildingPositionLine({ ...record, stateId: target }),
+                        description: 'Remap building-position state reference',
+                    },
+                ];
+        });
+        if (replacements.length > 0)
+            addChange(changes, relativePath, applyTextRanges(document, replacements), operationId, 'text/plain');
+    }
+}
+/** English names for new states: existing keys in mod files are replaced, others are appended. */
+function upsertStateNames(index, changes, entries, operationId) {
+    if (entries.length === 0)
+        return;
+    const defaultFile = `${index.sourceRoots.localisation[0] ?? 'localisation'}/english/hoi4_agent_map_l_english.yml`;
+    const working = new Map();
+    const current = (relativePath) => {
+        const key = normalizeRelative(relativePath);
+        const staged = working.get(key);
+        if (staged !== undefined)
+            return staged;
+        const change = changes.get(key);
+        if (change !== undefined)
+            return change.content ?? undefined;
+        return index.activeFiles.byRelativePath.get(key)?.bytes;
+    };
+    const paths = new Map();
+    for (const [key, value] of entries) {
+        const existing = index.localisationByKey.get(`l_english:${key}`) ?? [];
+        if (existing.length > 1)
+            throw new ServiceError('MAP_STATE_LOCALISATION_AMBIGUOUS', `English localisation key ${key} has multiple active definitions`, { key });
+        const target = existing[0]?.file.rootKind === 'mod' ? existing[0].file.relativePath : defaultFile;
+        const bytes = current(target);
+        paths.set(normalizeRelative(target), target);
+        if (bytes === undefined) {
+            working.set(normalizeRelative(target), encodeSource(`l_english:\n${key}: "${escapedLocalisationValue(value)}"\n`, 'utf8-bom'));
+            continue;
+        }
+        const document = parseLocalisation(bytes, target);
+        requireSafeLocalisationDocument(document, target);
+        const entry = document.entries.find((candidate) => candidate.key === key && candidate.language === 'l_english');
+        if (entry === undefined)
+            working.set(normalizeRelative(target), appendLocalisationEntry(document, key, value));
+        else
+            working.set(normalizeRelative(target), encodeSource(`${document.text.slice(0, entry.start)}${localisationEntryLine(document, entry, value)}${document.text.slice(entry.end)}`, 'utf8-bom'));
+    }
+    for (const [key, bytes] of [...working].sort(([left], [right]) => compareCodeUnits(left, right)))
+        addChange(changes, paths.get(key), bytes, operationId, 'text/yaml');
+}

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

@@ -0,0 +1,238 @@
+import { ServiceError } from '../core/result.js';
+import { BORDER_BARRIER_MASK, BORDER_FEATURE_BITS, BORDER_PROVINCE_KIND, } from './border-quality.js';
+import { buildProvinceGraph } from './partition-graph.js';
+/**
+ * The graph territory assignment grows countries over (ADR 0060). Provinces come from a border
+ * edge table of the border metric (ADR 0059), so the natural lines are exactly the ones the metric rewards:
+ * every shared border carries the strength of the features it lies on and the number of its pixel
+ * edges that count as natural. States (or any other grouping of provinces) are aggregated into
+ * atoms with the same two numbers, and the algorithm in `territory.ts` runs on atoms only.
+ */
+/** Weight of a natural feature when it forms part of a border, 0 (none) to 1 (impassable line). */
+export const TERRITORY_FEATURE_STRENGTH = {
+    river: 1,
+    extra: 1,
+    slope: 0.8,
+    terrainChange: 0.45,
+    lakeShore: 0.35,
+};
+/** Credit of a border edge towards natural border length: barrier features full, terrain half. */
+const BARRIER_CREDIT = 1;
+const TERRAIN_CREDIT = 0.5;
+/** Strength of one border edge from its feature bits (the strongest feature wins). */
+export function borderEdgeStrength(bits) {
+    let strength = 0;
+    if ((bits & BORDER_FEATURE_BITS.river) !== 0)
+        strength = Math.max(strength, TERRITORY_FEATURE_STRENGTH.river);
+    if ((bits & BORDER_FEATURE_BITS.extra) !== 0)
+        strength = Math.max(strength, TERRITORY_FEATURE_STRENGTH.extra);
+    if ((bits & BORDER_FEATURE_BITS.slope) !== 0)
+        strength = Math.max(strength, TERRITORY_FEATURE_STRENGTH.slope);
+    if ((bits & BORDER_FEATURE_BITS.terrainChange) !== 0)
+        strength = Math.max(strength, TERRITORY_FEATURE_STRENGTH.terrainChange);
+    if ((bits & BORDER_FEATURE_BITS.lakeShore) !== 0)
+        strength = Math.max(strength, TERRITORY_FEATURE_STRENGTH.lakeShore);
+    return strength;
+}
+export function borderEdgeCredit(bits) {
+    if ((bits & BORDER_BARRIER_MASK) !== 0)
+        return BARRIER_CREDIT;
+    if ((bits & BORDER_FEATURE_BITS.terrainChange) !== 0)
+        return TERRAIN_CREDIT;
+    return 0;
+}
+function graphKind(kind) {
+    return kind === BORDER_PROVINCE_KIND.land ? 1 : kind === BORDER_PROVINCE_KIND.lake ? 2 : 0;
+}
+/**
+ * Build the province graph of a map from the border edge table of the border metric (ADR 0059). The table holds
+ * every land border pixel edge with its natural features, so the mean strength and the natural
+ * length of each shared border are exact; borders with water have none.
+ */
+export function buildTerritoryProvinceGraph(table) {
+    const { width, height, provinceIds, provinceKinds } = table;
+    const count = provinceKinds.length;
+    if (count > 65_535)
+        throw new ServiceError('MAP_TERRITORY_TOO_MANY_PROVINCES', 'Territory assignment supports at most 65,535 provinces', { provinces: count });
+    const size = new Uint32Array(count);
+    const sumX = new Float64Array(count);
+    const sumY = new Float64Array(count);
+    let negative = false;
+    for (let y = 0; y < height; y += 1) {
+        const row = y * width;
+        for (let x = 0; x < width; x += 1) {
+            const id = provinceIds[row + x];
+            if (id < 0 || id >= count) {
+                negative = true;
+                continue;
+            }
+            size[id] += 1;
+            sumX[id] += x;
+            sumY[id] += y;
+        }
+    }
+    let pixel = provinceIds;
+    if (negative) {
+        pixel = new Int32Array(provinceIds.length);
+        for (let p = 0; p < pixel.length; p += 1) {
+            const id = provinceIds[p];
+            pixel[p] = id < 0 || id >= count ? 0 : id;
+        }
+    }
+    const graph = buildProvinceGraph({
+        width,
+        height,
+        pixel,
+        kind: Uint8Array.from(provinceKinds, graphKind),
+        size,
+        sumX,
+        sumY,
+    });
+    const credit = new Float32Array(graph.to.length);
+    const strength = new Float64Array(graph.to.length);
+    const slotOf = (from, to) => {
+        let low = graph.offsets[from];
+        let high = graph.offsets[from + 1] - 1;
+        while (low <= high) {
+            const middle = (low + high) >> 1;
+            const value = graph.to[middle];
+            if (value === to)
+                return middle;
+            if (value < to)
+                low = middle + 1;
+            else
+                high = middle - 1;
+        }
+        return -1;
+    };
+    for (let index = 0; index < table.edgeCount; index += 1) {
+        const a = table.provinceA[index];
+        const b = table.provinceB[index];
+        const bits = table.features[index];
+        const forward = slotOf(a, b);
+        const backward = slotOf(b, a);
+        if (forward < 0 || backward < 0)
+            continue;
+        const edgeCredit = borderEdgeCredit(bits);
+        const edgeStrength = borderEdgeStrength(bits);
+        credit[forward] += edgeCredit;
+        credit[backward] += edgeCredit;
+        strength[forward] += edgeStrength;
+        strength[backward] += edgeStrength;
+    }
+    for (let slot = 0; slot < strength.length; slot += 1)
+        graph.barrier[slot] = strength[slot] / Math.max(1, graph.length[slot]);
+    return { graph, credit, table, sumX, sumY, size };
+}
+/**
+ * The province graph of a partition (ADR 0058) as a territory province graph: its mean barrier
+ * strength per border gives the natural length (a border at full strength counts as natural).
+ * Used when the border edge table does not exist yet, as during world generation.
+ */
+export function territoryGraphFromPartition(graph, sumX, sumY) {
+    const credit = new Float32Array(graph.to.length);
+    for (let slot = 0; slot < credit.length; slot += 1)
+        credit[slot] = graph.length[slot] * Math.min(1, graph.barrier[slot] * 1.25);
+    return {
+        graph,
+        credit,
+        sumX: Float64Array.from({ length: graph.count }, (_, i) => sumX[i]),
+        sumY: Float64Array.from({ length: graph.count }, (_, i) => sumY[i]),
+        size: graph.size,
+    };
+}
+/**
+ * Aggregate provinces into atoms. `groups[i]` lists the provinces of atom `i`; every province must
+ * be land and appear once. `region` is optional and gives the group id of each atom.
+ */
+export function buildTerritoryAtoms(base, groups, region) {
+    const provinceCount = base.graph.count;
+    const atomOfProvince = new Int32Array(provinceCount).fill(-1);
+    const members = [];
+    for (const [atom, group] of groups.entries()) {
+        const sorted = [...group].sort((x, y) => x - y);
+        for (const province of sorted) {
+            if (province < 0 ||
+                province >= provinceCount ||
+                base.graph.kind[province] !== 1 ||
+                atomOfProvince[province] >= 0)
+                throw new ServiceError('MAP_TERRITORY_ATOM_INVALID', `Province ${province} cannot belong to atom ${atom}: it is not land or belongs to another atom`, { province, atom });
+            atomOfProvince[province] = atom;
+        }
+        members.push(sorted);
+    }
+    const count = members.length;
+    const size = new Uint32Array(count);
+    const sumX = new Float64Array(count);
+    const sumY = new Float64Array(count);
+    const rows = Array.from({ length: count }, () => new Map());
+    const { graph } = base;
+    for (let atom = 0; atom < count; atom += 1) {
+        const row = rows[atom];
+        for (const province of members[atom]) {
+            size[atom] += base.size[province];
+            sumX[atom] += base.sumX[province];
+            sumY[atom] += base.sumY[province];
+            for (let slot = graph.offsets[province]; slot < graph.offsets[province + 1]; slot += 1) {
+                const other = atomOfProvince[graph.to[slot]];
+                if (other < 0 || other === atom)
+                    continue;
+                const length = graph.length[slot];
+                const entry = row.get(other);
+                if (entry === undefined)
+                    row.set(other, [length, graph.barrier[slot] * length, base.credit[slot]]);
+                else {
+                    entry[0] += length;
+                    entry[1] += graph.barrier[slot] * length;
+                    entry[2] += base.credit[slot];
+                }
+            }
+        }
+    }
+    const offsets = new Int32Array(count + 1);
+    for (let atom = 0; atom < count; atom += 1)
+        offsets[atom + 1] = offsets[atom] + rows[atom].size;
+    const to = new Int32Array(offsets[count]);
+    const length = new Uint32Array(offsets[count]);
+    const barrier = new Float32Array(offsets[count]);
+    const credit = new Float32Array(offsets[count]);
+    for (let atom = 0; atom < count; atom += 1) {
+        let slot = offsets[atom];
+        for (const other of [...rows[atom].keys()].sort((x, y) => x - y)) {
+            const [pairLength, pairStrength, pairCredit] = rows[atom].get(other);
+            to[slot] = other;
+            length[slot] = pairLength;
+            barrier[slot] = pairStrength / Math.max(1, pairLength);
+            credit[slot] = pairCredit;
+            slot += 1;
+        }
+    }
+    const centerX = new Float32Array(count);
+    const centerY = new Float32Array(count);
+    for (let atom = 0; atom < count; atom += 1) {
+        const n = Math.max(1, size[atom]);
+        centerX[atom] = sumX[atom] / n;
+        centerY[atom] = sumY[atom] / n;
+    }
+    const atomGraph = {
+        count,
+        kind: new Uint8Array(count).fill(1),
+        offsets,
+        to,
+        length,
+        barrier,
+        centerX,
+        centerY,
+        width: graph.width,
+        height: graph.height,
+        size,
+    };
+    return {
+        count,
+        graph: atomGraph,
+        credit,
+        members,
+        atomOfProvince,
+        region: region ?? new Int32Array(count).fill(-1),
+    };
+}