hoi4-agent-tools 4.4.0 → 4.6.0

package/dist/hoi4_agent_tools/map/operations.js

@@ -9,12 +9,14 @@ import { derivedStateCapital, encodeTextDocument, LEVEL_STATE_BUILDINGS, MapWork
 import { planReferenceRemap, ReferenceRemapError } from './references.js';
 import { generateWorld } from './world.js';
 import { resolveEdge } from './world-edge.js';
+import { DEFAULT_AUTO_STRAIT_GAP_PX } from './gameplay/crossings.js';
 import { planMapPositions, planSupplyRebuild } from './derived.js';
-import { buildWorldContext } from './world-context.js';
-import { reconcileWorldOutputs } from './world-outputs.js';
+import { buildWorldContext, countryTagCatalog, WORLD_COUNTRY_TAG_FILE, } from './world-context.js';
+import { planWorldOutputs } from './world-outputs.js';
 import { resolvePartitionMode } from './partition.js';
+import { applyAssignTerritory, applyRepartitionStates, } from './territory-operations.js';
 import { unsupportedGeographyParts } from './relief/index.js';
-function* cancellationCheckpoint(signal, iteration = 0, stride = 1) {
+export function* cancellationCheckpoint(signal, iteration = 0, stride = 1) {
     if (iteration % stride !== 0)
         return;
     signal?.throwIfAborted();
@@ -41,7 +43,9 @@ async function completeCooperatively(steps, signal) {
         yieldDeadline = performance.now() + 8;
     }
 }
-function normalizeRelative(value) {
+/** Paths listed per kind in diagnostics and tool results; the artifact lists them all. */
+export const WORLD_OUTPUT_PATH_SAMPLE = 200;
+export function normalizeRelative(value) {
     return value.replaceAll('\\', '/').replace(/^\.\//u, '').toLowerCase();
 }
 function numberText(value) {
@@ -59,10 +63,10 @@ function required(value, code, message) {
 function quote(value) {
     return `"${value.replaceAll('\\', '\\\\').replaceAll('"', '\\"')}"`;
 }
-function uniqueSorted(values) {
+export function uniqueSorted(values) {
     return [...new Set(values)].sort((left, right) => left - right);
 }
-function uniqueStrings(values) {
+export function uniqueStrings(values) {
     return [...new Set(values)].sort((left, right) => compareCodeUnits(left, right));
 }
 function lineIndent(text, offset) {
@@ -108,7 +112,7 @@ function blockInsertion(block, documentText, content, newline) {
         description: 'Insert map source assignment',
     };
 }
-function cloneState(state) {
+export function cloneState(state) {
     return {
         id: state.id,
         name: state.name,
@@ -143,7 +147,7 @@ function compileHistory(data, indent, newline) {
     rows.push(...(data.datedHistory ?? []).map((block) => `${indent}\t${block}`));
     return rows.length === 0 ? `{ }` : `{${newline}${rows.join(newline)}${newline}${indent}}`;
 }
-function compileState(data, newline = '\n') {
+export function compileState(data, newline = '\n') {
     const resources = data.resources.size === 0
         ? ''
         : `\tresources = ${renderScalarMap(data.resources, '\t', newline)}${newline}`;
@@ -436,7 +440,7 @@ function patchDefinitionLine(source, updated) {
         replacements.set(7, String(updated.continent));
     return replaceDelimitedFields(line.text, replacements);
 }
-function applyTextRanges(document, replacements) {
+export function applyTextRanges(document, replacements) {
     const ordered = [...replacements].sort((left, right) => left.start - right.start || left.end - right.end);
     let cursor = 0;
     const pieces = [];
@@ -493,7 +497,7 @@ function patchDefinitions(index, updates, removals, additions) {
     }
     return applyTextRanges(document, replacements);
 }
-function rootEvidence(records) {
+export function rootEvidence(records) {
     const groups = new Map();
     for (const record of records) {
         const key = `${record.file.rootKind}:${record.file.loadOrder}`;
@@ -530,7 +534,7 @@ function contiguous(ids, start) {
     }
     return true;
 }
-function maximumObservedId(values, fallback) {
+export function maximumObservedId(values, fallback) {
     let maximum = fallback;
     for (const value of values) {
         if (!Number.isSafeInteger(value)) {
@@ -743,7 +747,7 @@ export function indexWithProposedChanges(base, changes, replacedRoots = []) {
     }
     return MapWorkspaceIndex.build(files, base.sourceRoots, base.sharedIndex.rebuild(files));
 }
-function addChange(changes, relativePath, content, operationId, mediaType) {
+export function addChange(changes, relativePath, content, operationId, mediaType) {
     const key = normalizeRelative(relativePath);
     const current = changes.get(key);
     if (current === undefined) {
@@ -772,9 +776,10 @@ function proposedChanges(changes) {
 }
 /** Source folders a new world replaces, per plan, so lower layers stop counting. */
 /** Diagnostics an operation raises while applying, drained into the plan after it succeeds. */
-const diagnosticsByPlan = new WeakMap();
+export const diagnosticsByPlan = new WeakMap();
 const replacedRootsByPlan = new WeakMap();
-function currentIndex(base, changes) {
+const worldOutputsByPlan = new WeakMap();
+export function currentIndex(base, changes) {
     return indexWithProposedChanges(base, proposedChanges(changes), replacedRootsByPlan.get(changes) ?? []);
 }
 function samePolicy(actual, expected) {
@@ -854,7 +859,7 @@ function requireSplitPolicy(operation) {
     }
     return policy;
 }
-function requireSafeLocalisationDocument(document, relativePath) {
+export function requireSafeLocalisationDocument(document, relativePath) {
     if (document.encoding !== 'utf8-bom') {
         throw new ServiceError('MAP_STATE_LOCALISATION_ENCODING_INVALID', 'State localisation edits require an existing UTF-8 BOM source file', { file: relativePath, encoding: document.encoding });
     }
@@ -863,7 +868,7 @@ function requireSafeLocalisationDocument(document, relativePath) {
         throw new ServiceError('MAP_STATE_LOCALISATION_SOURCE_INVALID', 'State localisation cannot target a malformed source file', { file: relativePath, diagnostics: errors.map(({ code }) => code) });
     }
 }
-function safeLocalisationRelativePath(index, requested) {
+export function safeLocalisationRelativePath(index, requested) {
     const value = requested.replaceAll('\\', '/');
     const segments = value.split('/');
     if (value === '' ||
@@ -881,7 +886,7 @@ function safeLocalisationRelativePath(index, requested) {
     }
     return value;
 }
-function escapedLocalisationValue(value) {
+export function escapedLocalisationValue(value) {
     return value
         .replaceAll('\\', '\\\\')
         .replaceAll('"', '\\"')
@@ -889,7 +894,7 @@ function escapedLocalisationValue(value) {
         .replaceAll('\r', '\\n')
         .replaceAll('\n', '\\n');
 }
-function localisationEntryLine(document, entry, value) {
+export function localisationEntryLine(document, entry, value) {
     const line = document.text.slice(entry.start, entry.end);
     const opening = line.indexOf('"');
     if (opening < 0)
@@ -915,7 +920,7 @@ function localisationEntryLine(document, entry, value) {
         throw new ServiceError('MAP_STATE_LOCALISATION_SOURCE_INVALID', 'State localisation source entry has an unclosed quoted value', { file: document.path, line: entry.line });
     return `${line.slice(0, opening + 1)}${escapedLocalisationValue(value)}${line.slice(closing)}`;
 }
-function appendLocalisationEntry(document, key, value) {
+export function appendLocalisationEntry(document, key, value) {
     let englishHeaders = 0;
     const matcher = /^\s*l_english:\s*(?:#.*)?$/gmu;
     while (matcher.exec(document.text) !== null && englishHeaders < 2)
@@ -1008,7 +1013,7 @@ function splitScalar(total, ratio, policy) {
  * count of slot buildings. A level applies to the whole state, so a split keeps it in both parts
  * and a merge keeps the highest; slot buildings are divided and summed.
  */
-function isLevelStateBuilding(index, building) {
+export function isLevelStateBuilding(index, building) {
     const definition = index.buildingDefinitions.get(building);
     if (definition !== undefined)
         return !definition.sharesSlots && !definition.provincial;
@@ -1076,7 +1081,7 @@ function mergeBounds(left, right) {
         count: left.count + right.count,
     };
 }
-function regionMembershipId(index, provinceId) {
+export function regionMembershipId(index, provinceId) {
     const regions = index.regionForProvince(provinceId);
     if (regions.length !== 1)
         throw new ServiceError('MAP_REGION_MEMBERSHIP_AMBIGUOUS', `Province ${provinceId} must have exactly one strategic region`);
@@ -1088,7 +1093,7 @@ function stateMembershipId(index, provinceId) {
         throw new ServiceError('MAP_STATE_MEMBERSHIP_AMBIGUOUS', `Province ${provinceId} belongs to multiple states`);
     return states[0]?.id;
 }
-function commitState(changes, state, data, fields, operationId, datedRewrite, datedRewriteFollowsProvinces = datedRewrite !== undefined) {
+export function commitState(changes, state, data, fields, operationId, datedRewrite, datedRewriteFollowsProvinces = datedRewrite !== undefined) {
     // Distributed dated history already follows the new province membership.
     assertDatedStateHistorySafe(state, datedRewriteFollowsProvinces
         ? { ...fields, provinces: false, victoryPoints: false, buildings: false }
@@ -1181,7 +1186,7 @@ function distributeDatedHistory(index, state, moved, ratio) {
     }
     return result;
 }
-function assertDatedStateHistorySafe(state, fields, operationId) {
+export function assertDatedStateHistorySafe(state, fields, operationId) {
     if (state.historyBlock === undefined)
         return;
     for (const entry of assignments(state.historyBlock)) {
@@ -1269,14 +1274,13 @@ function exactNumericMap(values, label) {
     }
     return result;
 }
-function applyUpdateState(base, changes, operation) {
-    const index = currentIndex(base, changes);
-    const state = index.statesById.get(operation.stateId);
+/** Apply one state update against an index that already holds every earlier change. */
+export function updateStateAgainst(index, changes, stateId, values, operationId) {
+    const state = index.statesById.get(stateId);
     if (state === undefined)
-        throw new ServiceError('MAP_STATE_NOT_FOUND', `State ${operation.stateId} does not exist`);
+        throw new ServiceError('MAP_STATE_NOT_FOUND', `State ${stateId} does not exist`);
     const desired = cloneState(state);
     const fields = {};
-    const values = operation.changes;
     if (values.capital !== undefined) {
         if (values.victoryPoints === undefined)
             throw new ServiceError('MAP_STATE_CAPITAL_ASSERTION_REQUIRES_VICTORY_POINTS', 'A derived state-capital assertion requires an exact victoryPoints payload');
@@ -1349,7 +1353,25 @@ function applyUpdateState(base, changes, operation) {
         desired.provinceBuildings = provinceBuildings;
         fields.buildings = true;
     }
-    commitState(changes, state, desired, fields, operation.id);
+    commitState(changes, state, desired, fields, operationId);
+}
+function applyUpdateState(base, changes, operation) {
+    updateStateAgainst(currentIndex(base, changes), changes, operation.stateId, operation.changes, operation.id);
+}
+/**
+ * Update many states in one operation: the index is built once and each state is patched in
+ * place, so a politics pass over thousands of states costs one validation. All or nothing.
+ */
+function applyUpdateStates(base, changes, operation) {
+    const seen = new Set();
+    for (const { stateId } of operation.updates) {
+        if (seen.has(stateId))
+            throw new ServiceError('MAP_UPDATE_STATES_DUPLICATE', `State ${stateId} appears twice in updates; merge its changes into one entry`, { stateId });
+        seen.add(stateId);
+    }
+    const index = currentIndex(base, changes);
+    for (const { stateId, changes: values } of operation.updates)
+        updateStateAgainst(index, changes, stateId, values, operation.id);
 }
 function applyMoveStateProvinces(base, changes, operation) {
     const policy = requireMovePolicy(operation);
@@ -1558,7 +1580,7 @@ function requireMergeStatePolicy(operation) {
         throw new ServiceError('MAP_STATE_DISTRIBUTION_REQUIRED', 'State merge requires a complete explicit value, ownership, port, network, position, and province-data distribution policy');
     }
 }
-function removalContent(index, file, label) {
+export function removalContent(index, file, label) {
     const lowerExists = index.sourceFiles.some((candidate) => normalizeRelative(candidate.relativePath) === normalizeRelative(file.relativePath) &&
         candidate.displayPath !== file.displayPath &&
         candidate.loadOrder < file.loadOrder);
@@ -2784,7 +2806,7 @@ function handleSimpleOperation(base, changes, operation) {
         addChange(changes, file.relativePath, content, operation.id, 'text/plain');
     }
 }
-function buildingPositionLine(value) {
+export function buildingPositionLine(value) {
     return [
         value.stateId,
         value.building,
@@ -3314,9 +3336,40 @@ function applyCreateWorld(base, changes, operation, context, signal) {
         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');
+    if (!hasGeography && operation.development?.model === 'geography')
+        throw new ServiceError('MAP_DEVELOPMENT_REQUIRES_GEOGRAPHY', 'development.model "geography" plans the economy from a geography model; give geography or geographyPath, or use "legacy"');
+    if (!hasGeography && operation.autoStraits !== undefined && operation.autoStraits !== false)
+        throw new ServiceError('MAP_AUTO_STRAITS_REQUIRES_GEOGRAPHY', 'autoStraits detects channels between the landmasses of a geography world; give geography or geographyPath, or remove autoStraits');
+    const autoStraits = operation.autoStraits === undefined || operation.autoStraits === false
+        ? undefined
+        : {
+            maxGapPx: operation.autoStraits === true
+                ? DEFAULT_AUTO_STRAIT_GAP_PX
+                : (operation.autoStraits.maxGapPx ?? DEFAULT_AUTO_STRAIT_GAP_PX),
+        };
+    const workspaceCountries = operation.countries !== undefined && !Array.isArray(operation.countries)
+        ? operation.countries
+        : undefined;
+    const tagCatalog = countryTagCatalog(base);
+    if (workspaceCountries !== undefined) {
+        const declared = new Set(tagCatalog.static);
+        const dynamicTags = new Set(tagCatalog.dynamic);
+        for (const realm of workspaceCountries.realms) {
+            if (dynamicTags.has(realm.tag))
+                throw new ServiceError('MAP_WORLD_REALM_TAG_DYNAMIC', `${realm.tag} is a dynamic tag; a world can only place countries with static tags`, { tag: realm.tag });
+            if (!declared.has(realm.tag))
+                throw new ServiceError('MAP_WORLD_REALM_TAG_UNKNOWN', `No active common/country_tags file other than the generated world's declares ${realm.tag}`, { tag: realm.tag });
+        }
+    }
     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');
+    if (operation.synthesisCheck === true && context.synthesisCheck !== true)
+        throw new ServiceError('MAP_SYNTHESIS_CHECK_REQUIRES_PREVIEW', "synthesisCheck checks the model's rivers without writing; call hoi4.map_rewrite with preview: true, or remove synthesisCheck to write the world");
+    if (operation.synthesisCheck === true && !hasGeography)
+        throw new ServiceError('MAP_SYNTHESIS_CHECK_REQUIRES_GEOGRAPHY', 'synthesisCheck runs the relief and river synthesis of a geography model; give geography or geographyPath');
+    if (partitionMode === 'legacy' && operation.borderQuality === 'enforce')
+        throw new ServiceError('MAP_BORDER_QUALITY_ENFORCE_NEEDS_FEATURE_AWARE', 'borderQuality "enforce" needs the feature-aware partition: the legacy partition cuts at chance level against rivers and slopes and would block every write. Set partition to "feature-aware", or use "report"');
     const world = generateWorld({
         startingScenario,
         ...(operation.worldName === undefined ? {} : { worldName: operation.worldName }),
@@ -3332,13 +3385,29 @@ function applyCreateWorld(base, changes, operation, context, signal) {
         provincesPerState: operation.provincesPerState ?? (reference === undefined ? 5 : 12),
         landProvincesPerRegion: operation.landProvincesPerRegion ?? (reference === undefined ? 25 : 60),
         seaProvincesPerRegion: operation.seaProvincesPerRegion ?? (reference === undefined ? 10 : 30),
-        countries: operation.countries ??
+        countries: workspaceCountries?.realms.map((realm) => ({
+            tag: realm.tag,
+            name: realm.tag,
+            ...(realm.weight === undefined ? {} : { share: realm.weight }),
+        })) ??
+            operation.countries ??
             reference?.countries ?? [
             { tag: 'X01', name: 'Aster' },
             { tag: 'X02', name: 'Brum' },
             { tag: 'X03', name: 'Corvel' },
             { tag: 'X04', name: 'Doran' },
         ],
+        ...(workspaceCountries === undefined
+            ? {}
+            : {
+                realms: {
+                    list: workspaceCountries.realms,
+                    ...(workspaceCountries.unowned === undefined
+                        ? {}
+                        : { unowned: workspaceCountries.unowned }),
+                    islands: workspaceCountries.islands ?? 'nearest',
+                },
+            }),
         ...(reference === undefined
             ? {}
             : {
@@ -3375,6 +3444,10 @@ function applyCreateWorld(base, changes, operation, context, signal) {
             }),
         ...(edge.mode === 'none' ? {} : { edge }),
         ...(operation.ambientFrame === true ? { ambientFrame: true } : {}),
+        ...(autoStraits === undefined ? {} : { autoStraits }),
+        ...(operation.development?.model === undefined
+            ? {}
+            : { developmentModel: operation.development.model }),
         colormapProfile,
         ...(partitionMode === 'legacy'
             ? {}
@@ -3390,7 +3463,25 @@ function applyCreateWorld(base, changes, operation, context, signal) {
         ...(operation.colormap?.palette === undefined
             ? {}
             : { colormapPalette: colormapPaletteOverrides(operation.colormap.palette) }),
-    }, buildWorldContext(base), { signal });
+    }, buildWorldContext(base), { signal, ...(operation.synthesisCheck === true ? { riverCheck: true } : {}) });
+    if (operation.synthesisCheck === true)
+        return [
+            ...world.notes.map((note) => ({
+                code: note.code,
+                severity: note.severity,
+                category: 'map',
+                operationId: operation.id,
+                message: note.message,
+                ...(note.details === undefined ? {} : { details: note.details }),
+            })),
+            {
+                code: 'MAP_SYNTHESIS_CHECK_READY',
+                severity: 'info',
+                category: 'map',
+                operationId: operation.id,
+                message: `Every river of the model reaches its mouth over the synthesised relief of a ${world.summary.width}x${world.summary.height} map; nothing was written`,
+            },
+        ];
     const roots = operation.replaceBaseGame === false
         ? []
         : [...WORLD_REPLACED_ROOTS, ...(startingScenario ? STARTING_SCENARIO_REPLACED_ROOTS : [])];
@@ -3398,7 +3489,7 @@ function applyCreateWorld(base, changes, operation, context, signal) {
     for (const file of world.files)
         addChange(changes, file.relativePath, file.content, operation.id, file.mediaType);
     // Remove only unchanged outputs recorded by a previous generation, before indexing new IDs.
-    for (const file of reconcileWorldOutputs(base.sourceFiles, proposedChanges(changes), operation.id, mapRoot, base.sourceRoots.states, base.sourceRoots.localisation))
+    for (const file of planWorldOutputs(base.sourceFiles, proposedChanges(changes), operation.id, mapRoot, base.sourceRoots.states, base.sourceRoots.localisation, { releaseCountryOutputs: workspaceCountries !== undefined }).changes)
         if (file.content === null)
             addChange(changes, file.relativePath, null, operation.id, 'text/plain');
     // Start from empty derived files so no base-game position or supply line survives.
@@ -3416,10 +3507,21 @@ function applyCreateWorld(base, changes, operation, context, signal) {
     for (const file of planMapPositions(generated, { mode: 'replace' }))
         addChange(changes, file.relativePath, file.content, operation.id, 'text/plain');
     const positioned = currentIndex(base, changes);
-    for (const file of planSupplyRebuild(positioned, { mode: 'replace' }))
+    for (const file of planSupplyRebuild(positioned, {
+        mode: 'replace',
+        ...(world.railCost === undefined ? {} : { railCost: world.railCost }),
+    }))
         addChange(changes, file.relativePath, file.content, operation.id, 'text/plain');
-    for (const file of reconcileWorldOutputs(base.sourceFiles, proposedChanges(changes), operation.id, mapRoot, base.sourceRoots.states, base.sourceRoots.localisation))
+    const outputs = planWorldOutputs(base.sourceFiles, proposedChanges(changes), operation.id, mapRoot, base.sourceRoots.states, base.sourceRoots.localisation, { releaseCountryOutputs: workspaceCountries !== undefined });
+    for (const file of outputs.changes)
         addChange(changes, file.relativePath, file.content, operation.id, file.mediaType ?? 'text/plain');
+    worldOutputsByPlan.set(changes, {
+        operationId: operation.id,
+        written: outputs.written,
+        retired: outputs.retired,
+        released: outputs.released,
+        ...(world.realms === undefined ? {} : { realms: world.realms }),
+    });
     return [
         ...(reference?.diagnostics ?? []).map((message) => ({
             code: 'MAP_REFERENCE_INTERPRETATION',
@@ -3448,6 +3550,24 @@ function applyCreateWorld(base, changes, operation, context, signal) {
                     details: { warningCount: world.warnings.length, samples: world.warnings.slice(0, 5) },
                 },
             ]),
+        worldOutputsDiagnostic(operation.id, outputs),
+        ...worldTagDiagnostics(operation.id, tagCatalog, world, workspaceCountries !== undefined),
+        ...worldRealmDiagnostics(operation.id, world),
+        ...(outputs.released.length === 0
+            ? []
+            : [
+                {
+                    code: 'MAP_WORLD_OUTPUT_RELEASED',
+                    severity: 'info',
+                    category: 'map',
+                    operationId: operation.id,
+                    message: `${outputs.released.length} edited country file(s) of the previous world are left to the workspace and no longer recorded as generated`,
+                    details: {
+                        count: outputs.released.length,
+                        files: outputs.released.slice(0, WORLD_OUTPUT_PATH_SAMPLE),
+                    },
+                },
+            ]),
         {
             code: 'MAP_WORLD_CREATED',
             severity: 'info',
@@ -3470,6 +3590,107 @@ function applyCreateWorld(base, changes, operation, context, signal) {
             ]),
     ];
 }
+/** Tag count observed to overflow the flag sheet of one 1.19 Windows build; never a block. */
+export const WORLD_TAG_COUNT_OBSERVED_LIMIT = 439;
+function worldTagDiagnostics(operationId, catalog, world, workspaceOwned) {
+    const declared = new Set(catalog.static);
+    const generated = workspaceOwned
+        ? 0
+        : worldGeneratedTags(world).filter((tag) => !declared.has(tag)).length;
+    const total = declared.size + generated + catalog.dynamic.length;
+    const details = {
+        static: declared.size + generated,
+        generated,
+        dynamic: catalog.dynamic.length,
+        total,
+        observedLimit: WORLD_TAG_COUNT_OBSERVED_LIMIT,
+    };
+    return [
+        {
+            code: 'MAP_WORLD_TAG_COUNT',
+            severity: 'info',
+            category: 'map',
+            operationId,
+            message: `After this write ${total} country tags are declared: ${details.static} static (${generated} written by the world) and ${details.dynamic} dynamic`,
+            details,
+        },
+        ...(total <= WORLD_TAG_COUNT_OBSERVED_LIMIT
+            ? []
+            : [
+                {
+                    code: 'MAP_WORLD_TAG_COUNT_HIGH',
+                    severity: 'warning',
+                    category: 'map',
+                    operationId,
+                    message: `${total} country tags exceed ${WORLD_TAG_COUNT_OBSERVED_LIMIT}, the count at which one measured game build overflowed its flag sheet`,
+                    details,
+                },
+            ]),
+    ];
+}
+/** Tags of the country files a generated world writes. */
+function worldGeneratedTags(world) {
+    const file = world.files.find(({ relativePath }) => relativePath === WORLD_COUNTRY_TAG_FILE);
+    if (file === undefined)
+        return [];
+    return [
+        ...new Set([...file.content.toString('utf8').matchAll(/^([A-Z][A-Z0-9]{2}) =/gmu)].map((match) => match[1])),
+    ];
+}
+function worldRealmDiagnostics(operationId, world) {
+    if (world.realms === undefined)
+        return [];
+    const { countries, unownedStates } = world.realms;
+    return [
+        {
+            code: 'MAP_WORLD_REALMS_PLACED',
+            severity: 'info',
+            category: 'map',
+            operationId,
+            message: `Placed ${countries.length} workspace countries; their country files, histories, flags and names stay the workspace's`,
+            details: {
+                countries: countries
+                    .slice(0, 100)
+                    .map(({ tag, capitalState, states, landShare, targetShare }) => ({
+                    tag,
+                    capitalState,
+                    states: states.length,
+                    landShare,
+                    targetShare,
+                })),
+                truncated: countries.length > 100,
+            },
+        },
+        ...(unownedStates.length === 0
+            ? []
+            : [
+                {
+                    code: 'MAP_WORLD_STATE_UNOWNED',
+                    severity: 'info',
+                    category: 'map',
+                    operationId,
+                    message: `${unownedStates.length} state(s) have no owner, as the request asks; whether the game build accepts unowned land is for the mod to verify`,
+                    details: { count: unownedStates.length, states: unownedStates.slice(0, 200) },
+                },
+            ]),
+    ];
+}
+function worldOutputsDiagnostic(operationId, outputs) {
+    return {
+        code: 'MAP_WORLD_OUTPUTS_RECONCILED',
+        severity: 'info',
+        category: 'map',
+        operationId,
+        message: `The world records ${outputs.written.length} generated file(s), retires ${outputs.retired.length} earlier output(s) it no longer writes and releases ${outputs.released.length} to the workspace`,
+        details: {
+            written: outputs.written.length,
+            retired: outputs.retired.length,
+            released: outputs.released.length,
+            retiredFiles: outputs.retired.slice(0, WORLD_OUTPUT_PATH_SAMPLE),
+            truncated: outputs.retired.length > WORLD_OUTPUT_PATH_SAMPLE,
+        },
+    };
+}
 function applyRegenerateMapPositions(base, changes, operation) {
     const index = currentIndex(base, changes);
     for (const file of planMapPositions(index, operation))
@@ -3484,7 +3705,7 @@ function applyRebuildSupply(base, changes, operation) {
  * Rewrite the script references of one entity kind in the proposed changes. Returns the number
  * of script files changed; an empty result is an error only when the caller asks for it.
  */
-function remapScriptReferences(base, changes, operationId, request) {
+export function remapScriptReferences(base, changes, operationId, request) {
     const index = currentIndex(base, changes);
     let plan;
     try {
@@ -3567,6 +3788,8 @@ function* planMapOperationSteps(base, operations, signal, context = {}) {
     const allocations = [];
     let expectedChangedBounds;
     const manifestOperations = [];
+    const territory = [];
+    const worldOutputs = [];
     const ids = new Set();
     for (const [operationIndex, operation] of operations.entries()) {
         yield* cancellationCheckpoint(signal, operationIndex);
@@ -3595,13 +3818,31 @@ function* planMapOperationSteps(base, operations, signal, context = {}) {
         ]));
         const allocationsCheckpoint = allocations.length;
         const boundsCheckpoint = expectedChangedBounds;
+        const territoryCheckpoint = territory.length;
         try {
-            if (operation.kind === 'create_world')
+            if (operation.kind === 'create_world') {
                 diagnostics.push(...applyCreateWorld(base, changes, operation, context, signal));
+                const outputs = worldOutputsByPlan.get(changes);
+                worldOutputsByPlan.delete(changes);
+                if (outputs !== undefined)
+                    worldOutputs.push(outputs);
+            }
             else if (operation.kind === 'move_state_provinces')
                 applyMoveStateProvinces(base, changes, operation);
+            else if (operation.kind === 'assign_territory') {
+                const outcome = yield* applyAssignTerritory(base, changes, allocations, operation, signal);
+                diagnostics.push(...outcome.diagnostics);
+                territory.push(outcome.report);
+            }
+            else if (operation.kind === 'repartition_states') {
+                const outcome = yield* applyRepartitionStates(base, changes, allocations, operation, signal);
+                diagnostics.push(...outcome.diagnostics);
+                territory.push(outcome.report);
+            }
             else if (operation.kind === 'update_state')
                 applyUpdateState(base, changes, operation);
+            else if (operation.kind === 'update_states')
+                applyUpdateStates(base, changes, operation);
             else if (operation.kind === 'split_state' || operation.kind === 'create_state')
                 yield* applySplitState(base, changes, allocations, operation, signal);
             else if (operation.kind === 'merge_states')
@@ -3641,6 +3882,7 @@ function* planMapOperationSteps(base, operations, signal, context = {}) {
                 changes.set(key, change);
             allocations.length = allocationsCheckpoint;
             expectedChangedBounds = boundsCheckpoint;
+            territory.length = territoryCheckpoint;
             const serviceError = error instanceof ServiceError
                 ? error
                 : new ServiceError('MAP_OPERATION_FAILED', error instanceof Error ? error.message : String(error));
@@ -3674,6 +3916,8 @@ function* planMapOperationSteps(base, operations, signal, context = {}) {
         ...(expectedChangedBounds === undefined ? {} : { expectedChangedBounds }),
         finalIndex,
         operations: manifestOperations,
+        ...(territory.length === 0 ? {} : { territory }),
+        ...(worldOutputs.length === 0 ? {} : { worldOutputs }),
     };
 }
 export function planMapOperations(base, operations, signal, context = {}) {

package/dist/hoi4_agent_tools/map/reference-preparation.js

@@ -248,8 +248,11 @@ export async function prepareReferenceWorld(resolver, workspaceId, operation, pr
         return id === 0 ? undefined : id;
     };
     let countries;
-    if (operation.countries !== undefined)
+    if (Array.isArray(operation.countries))
         countries = operation.countries;
+    // Workspace-owned countries are placed from their own points; the picture's colours are unused.
+    else if (operation.countries !== undefined)
+        countries = [];
     else if (surface.inferredCountries.length > 1) {
         countries = surface.inferredCountries.slice(0, 200).map((country, index) => ({
             tag: `X${(index + 1).toString(36).toUpperCase().padStart(2, '0')}`,