hoi4-agent-tools 4.3.0 → 4.5.0

package/dist/hoi4_agent_tools/map/model.js

@@ -4,7 +4,7 @@ import { SymbolIndex } from '../core/index.js';
 import { assertRenderDimensions } from '../core/render-budget.js';
 import { addMapDiagnostic, addMapDiagnostics } from './diagnostic-limit.js';
 import { ServiceError } from '../core/result.js';
-import { assignments, childBlocks, decodeSource, encodeSource, firstScalar, nodeLocation, parseClausewitz, parseLocalisation, } from '../core/source/index.js';
+import { assignments, assertSourceEncodingPreserved, childBlocks, decodeSource, encodeSource, firstScalar, nodeLocation, parseClausewitz, parseLocalisation, } from '../core/source/index.js';
 import { BmpImage, rgbKey } from './bmp.js';
 const defaultMapIndexSourceRoots = {
     map: ['map'],
@@ -87,7 +87,11 @@ export function selectActiveFiles(files) {
 }
 export function parseTextDocument(file) {
     if (file.bytes.length > MAP_TEXT_MAX_BYTES) {
-        throw new ServiceError('MAP_TEXT_FILE_LIMIT', 'Map text table exceeds the supported 16 MiB parsing limit', { bytes: file.bytes.length, maximumBytes: MAP_TEXT_MAX_BYTES });
+        throw new ServiceError('MAP_TEXT_FILE_LIMIT', `Map text table ${file.relativePath} exceeds the supported 16 MiB parsing limit (${file.bytes.length} bytes)`, {
+            relativePath: file.relativePath,
+            bytes: file.bytes.length,
+            maximumBytes: MAP_TEXT_MAX_BYTES,
+        });
     }
     const decoded = decodeSource(file.bytes);
     const lines = [];
@@ -101,7 +105,11 @@ export function parseTextDocument(file) {
         const text = full.replace(/(?:\r\n|\n|\r)$/u, '');
         const start = match.index;
         if (index >= MAP_TEXT_MAX_RECORDS) {
-            throw new ServiceError('MAP_TEXT_RECORD_LIMIT', 'Map text table exceeds the supported record limit', { records: index + 1, maximumRecords: MAP_TEXT_MAX_RECORDS });
+            throw new ServiceError('MAP_TEXT_RECORD_LIMIT', `Map text table ${file.relativePath} exceeds the supported record limit`, {
+                relativePath: file.relativePath,
+                records: index + 1,
+                maximumRecords: MAP_TEXT_MAX_RECORDS,
+            });
         }
         lines.push({ index, start, end: start + text.length, fullEnd: start + full.length, text });
         index += 1;
@@ -111,6 +119,7 @@ export function parseTextDocument(file) {
     return { ...decoded, file, lines };
 }
 export function encodeTextDocument(document, text) {
+    assertSourceEncodingPreserved(document, document.file.displayPath);
     return encodeSource(text, document.encoding);
 }
 function lineLocation(document, line) {
@@ -1114,6 +1123,9 @@ export class MapWorkspaceIndex {
     railwayFile;
     /** The active heightmap, when the scan included it; decoded on first use. */
     heightmapFile;
+    /** The active river and terrain bitmaps, when the scan included them (border quality). */
+    riversFile;
+    terrainBitmapFile;
     #heightmap;
     /**
      * Map height (the Y coordinate) at a bitmap pixel: the heightmap value divided by ten, as the
@@ -1297,6 +1309,8 @@ export class MapWorkspaceIndex {
                 ? undefined
                 : parseTerrainCategories(terrainFiles, this.diagnostics);
         this.heightmapFile = mapFile(this.activeFiles, defaultMapSelectorValue(this.defaultMapFile, 'heightmap', 'heightmap.bmp'), this.sourceRoots.map);
+        this.riversFile = mapFile(this.activeFiles, defaultMapSelectorValue(this.defaultMapFile, 'rivers', 'rivers.bmp'), this.sourceRoots.map);
+        this.terrainBitmapFile = mapFile(this.activeFiles, defaultMapSelectorValue(this.defaultMapFile, 'terrain', 'terrain.bmp'), this.sourceRoots.map);
         const buildingFiles = this.activeFiles.all.filter((file) => /^common\/buildings\/[^/]+\.txt$/iu.test(normalizedPath(file.relativePath)));
         const buildings = parseBuildingDefinitions(buildingFiles, []);
         this.buildingDefinitions = buildings.definitions;

package/dist/hoi4_agent_tools/map/operations.js

@@ -1,6 +1,6 @@
 import path from 'node:path';
 import { setImmediate as yieldToEventLoop } from 'node:timers/promises';
-import { compareCodeUnits, deterministicId, sha256Bytes } from '../core/canonical.js';
+import { canonicalJson, compareCodeUnits, deterministicId, sha256Bytes, } from '../core/canonical.js';
 import { ServiceError } from '../core/result.js';
 import { applyReplacements, assignments, encodeSource, parseLocalisation, parseClausewitz, } from '../core/source/index.js';
 import { rgbKey } from './bmp.js';
@@ -8,9 +8,12 @@ import { MAP_MASK_CELL_LIMIT, MAP_POLYGON_WORK_LIMIT, MAP_SELECTED_OFFSET_BYTES,
 import { derivedStateCapital, encodeTextDocument, LEVEL_STATE_BUILDINGS, MapWorkspaceIndex, parseMapDate, parseTextDocument, } from './model.js';
 import { planReferenceRemap, ReferenceRemapError } from './references.js';
 import { generateWorld } from './world.js';
+import { resolveEdge } from './world-edge.js';
 import { planMapPositions, planSupplyRebuild } from './derived.js';
-import { buildWorldContext } from './world-context.js';
-import { reconcileWorldOutputs } from './world-outputs.js';
+import { buildWorldContext, countryTagCatalog, WORLD_COUNTRY_TAG_FILE, } from './world-context.js';
+import { planWorldOutputs } from './world-outputs.js';
+import { resolvePartitionMode } from './partition.js';
+import { unsupportedGeographyParts } from './relief/index.js';
 function* cancellationCheckpoint(signal, iteration = 0, stride = 1) {
     if (iteration % stride !== 0)
         return;
@@ -38,6 +41,8 @@ async function completeCooperatively(steps, signal) {
         yieldDeadline = performance.now() + 8;
     }
 }
+/** Paths listed per kind in diagnostics and tool results; the artifact lists them all. */
+export const WORLD_OUTPUT_PATH_SAMPLE = 200;
 function normalizeRelative(value) {
     return value.replaceAll('\\', '/').replace(/^\.\//u, '').toLowerCase();
 }
@@ -771,6 +776,7 @@ function proposedChanges(changes) {
 /** Diagnostics an operation raises while applying, drained into the plan after it succeeds. */
 const diagnosticsByPlan = new WeakMap();
 const replacedRootsByPlan = new WeakMap();
+const worldOutputsByPlan = new WeakMap();
 function currentIndex(base, changes) {
     return indexWithProposedChanges(base, proposedChanges(changes), replacedRootsByPlan.get(changes) ?? []);
 }
@@ -3272,33 +3278,100 @@ function descriptorWithReplacePaths(index, roots) {
     const body = textValue.endsWith('\n') ? textValue : `${textValue}${newline}`;
     return Buffer.from(`${body}${missing.map((root) => `replace_path="${root}"`).join(newline)}${missing.length > 0 ? newline : ''}`, 'utf8');
 }
-function applyCreateWorld(base, changes, operation, context) {
+function colormapPaletteOverrides(palette) {
+    return Object.fromEntries(Object.entries(palette).flatMap(([name, color]) => color === undefined ? [] : [[name, [color.r, color.g, color.b]]]));
+}
+function applyCreateWorld(base, changes, operation, context, signal) {
+    const geography = context.geographyModels?.get(operation.id);
+    const hasGeography = operation.geography !== undefined || operation.geographyPath !== undefined;
+    if (hasGeography) {
+        if (geography === undefined)
+            throw new ServiceError('MAP_GEOGRAPHY_NOT_PREPARED', 'Geography models must be prepared by the authorized workspace service');
+        if (!geography.valid)
+            throw new ServiceError('MAP_GEOGRAPHY_INVALID', 'The geography model has errors; fix them (see the MAP_GEOGRAPHY_* diagnostics and map-geography-report.json) before generating a world', { modelHash: geography.geography.hash });
+        const pending = unsupportedGeographyParts(geography.geography);
+        if (pending.length > 0)
+            throw new ServiceError('MAP_GEOGRAPHY_SYNTHESIS_UNAVAILABLE', `The geography model is valid and its relief, rivers and lakes can be synthesized, but this version cannot yet use ${pending.join(', ')} (the climate and biome stage); remove them from the model to generate relief and rivers only, or use preview:true to review the model overlay and report`, {
+                modelHash: geography.geography.hash,
+                available: ['relief', 'rivers', 'lakes'],
+                unavailable: pending,
+            });
+    }
+    else {
+        if (operation.relief !== undefined)
+            throw new ServiceError('MAP_RELIEF_REQUIRES_GEOGRAPHY', 'relief shapes the terrain synthesised from a geography model; give geography or geographyPath, or remove relief');
+        if (typeof operation.rivers === 'object')
+            throw new ServiceError('MAP_RIVER_DENSITY_REQUIRES_GEOGRAPHY', 'rivers { density } sets the river network of a geography world; give geography or geographyPath, or use an integer count');
+    }
     const reference = context.referenceWorlds?.get(operation.id);
     if (operation.reference !== undefined && reference === undefined)
         throw new ServiceError('MAP_REFERENCE_NOT_PREPARED', 'Reference worlds must be prepared by the authorized workspace service');
     const mapRoot = base.sourceRoots.map[0] ?? 'map';
     const startingScenario = operation.startingScenario ?? reference !== undefined;
+    const worldWidth = operation.width ?? reference?.surface.width ?? 1_024;
+    const worldHeight = operation.height ?? reference?.surface.height ?? 512;
+    const edge = resolveEdge(operation.edge, worldWidth, worldHeight);
+    const look = operation.look;
+    const colormapProfile = operation.colormap?.profile ?? (look === undefined ? 'legacy' : 'calibrated');
+    if (look === 'custom' && operation.colormap?.palette === undefined)
+        throw new ServiceError('MAP_LOOK_CUSTOM_PALETTE_REQUIRED', 'look "custom" needs colormap.palette with at least one class colour');
+    if (colormapProfile === 'legacy' && look !== undefined)
+        throw new ServiceError('MAP_LOOK_REQUIRES_CALIBRATED_COLORMAP', 'look selects a calibrated palette; remove colormap.profile "legacy" or look');
+    const 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');
     const world = generateWorld({
         startingScenario,
         ...(operation.worldName === undefined ? {} : { worldName: operation.worldName }),
-        width: operation.width ?? reference?.surface.width ?? 1_024,
-        height: operation.height ?? reference?.surface.height ?? 512,
+        width: worldWidth,
+        height: worldHeight,
         seed: operation.seed ?? 1,
         landCoverage: operation.landCoverage ?? 0.35,
         continents: operation.continents ?? 3,
         ...(operation.landPolygons === undefined ? {} : { landPolygons: operation.landPolygons }),
         landProvincePixels: operation.landProvincePixels ?? 400,
         seaProvincePixels: operation.seaProvincePixels ?? 2_500,
+        provinceSizesDefaulted: operation.landProvincePixels === undefined && operation.seaProvincePixels === undefined,
         provincesPerState: operation.provincesPerState ?? (reference === undefined ? 5 : 12),
         landProvincesPerRegion: operation.landProvincesPerRegion ?? (reference === undefined ? 25 : 60),
         seaProvincesPerRegion: operation.seaProvincesPerRegion ?? (reference === undefined ? 10 : 30),
-        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
             ? {}
             : {
@@ -3310,8 +3383,47 @@ function applyCreateWorld(base, changes, operation, context) {
             ? {}
             : { continentNames: operation.continentNames }),
         startDate: operation.startDate ?? '1936.1.1',
-        rivers: operation.rivers ?? (reference === undefined ? 8 : 80),
-    }, buildWorldContext(base));
+        rivers: typeof operation.rivers === 'number' ? operation.rivers : reference === undefined ? 8 : 80,
+        ...(geography === undefined
+            ? {}
+            : {
+                geography: geography.geography,
+                ...(operation.relief === undefined
+                    ? {}
+                    : {
+                        relief: {
+                            ...(operation.relief.scale === undefined
+                                ? {}
+                                : { scale: operation.relief.scale }),
+                            ...(operation.relief.detail === undefined
+                                ? {}
+                                : { detail: operation.relief.detail }),
+                        },
+                    }),
+                ...(typeof operation.rivers === 'object'
+                    ? { riverDensity: operation.rivers.density }
+                    : typeof operation.rivers === 'number'
+                        ? { riverCount: operation.rivers }
+                        : {}),
+            }),
+        ...(edge.mode === 'none' ? {} : { edge }),
+        ...(operation.ambientFrame === true ? { ambientFrame: true } : {}),
+        colormapProfile,
+        ...(partitionMode === 'legacy'
+            ? {}
+            : {
+                partition: {
+                    mode: partitionMode,
+                    ...(operation.partitionTuning === undefined
+                        ? {}
+                        : { tuning: operation.partitionTuning }),
+                },
+            }),
+        ...(look === undefined ? {} : { look }),
+        ...(operation.colormap?.palette === undefined
+            ? {}
+            : { colormapPalette: colormapPaletteOverrides(operation.colormap.palette) }),
+    }, buildWorldContext(base), { signal });
     const roots = operation.replaceBaseGame === false
         ? []
         : [...WORLD_REPLACED_ROOTS, ...(startingScenario ? STARTING_SCENARIO_REPLACED_ROOTS : [])];
@@ -3319,7 +3431,7 @@ function applyCreateWorld(base, changes, operation, context) {
     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.
@@ -3339,8 +3451,16 @@ function applyCreateWorld(base, changes, operation, context) {
     const positioned = currentIndex(base, changes);
     for (const file of planSupplyRebuild(positioned, { mode: 'replace' }))
         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',
@@ -3349,6 +3469,14 @@ function applyCreateWorld(base, changes, operation, context) {
             operationId: operation.id,
             message,
         })),
+        ...world.notes.map((note) => ({
+            code: note.code,
+            severity: note.severity,
+            category: 'map',
+            operationId: operation.id,
+            message: note.message,
+            ...(note.details === undefined ? {} : { details: note.details }),
+        })),
         ...(world.warnings.length === 0
             ? []
             : [
@@ -3361,6 +3489,24 @@ function applyCreateWorld(base, changes, operation, context) {
                     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',
@@ -3383,6 +3529,107 @@ function applyCreateWorld(base, changes, operation, context) {
             ]),
     ];
 }
+/** 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))
@@ -3456,6 +3703,22 @@ function applyEntityLocator(base, changes, operation) {
     ]);
     addChange(changes, locator.file.relativePath, output, operation.id, 'text/plain');
 }
+/**
+ * The operation as the transaction manifest records it. An inline geography model can hold
+ * megabytes; the manifest keeps its SHA-256 and size instead, which still bind the plan hash to
+ * the exact model, and a model given by path is bound by the file's read dependency.
+ */
+function manifestOperationData(operation) {
+    const data = JSON.parse(JSON.stringify(operation));
+    if (operation.kind === 'create_world' && operation.geography !== undefined) {
+        const canonical = canonicalJson(operation.geography);
+        data.geography = {
+            sha256: sha256Bytes(canonical),
+            bytes: Buffer.byteLength(canonical, 'utf8'),
+        };
+    }
+    return data;
+}
 function* planMapOperationSteps(base, operations, signal, context = {}) {
     yield* cancellationCheckpoint(signal);
     const changes = new Map();
@@ -3464,6 +3727,7 @@ function* planMapOperationSteps(base, operations, signal, context = {}) {
     const allocations = [];
     let expectedChangedBounds;
     const manifestOperations = [];
+    const worldOutputs = [];
     const ids = new Set();
     for (const [operationIndex, operation] of operations.entries()) {
         yield* cancellationCheckpoint(signal, operationIndex);
@@ -3480,7 +3744,7 @@ function* planMapOperationSteps(base, operations, signal, context = {}) {
             id: operation.id,
             kind: operation.kind,
             summary: operation.summary ?? operation.kind.replaceAll('_', ' '),
-            data: JSON.parse(JSON.stringify(operation)),
+            data: manifestOperationData(operation),
         });
         const changesCheckpoint = new Map([...changes].map(([key, change]) => [
             key,
@@ -3493,8 +3757,13 @@ function* planMapOperationSteps(base, operations, signal, context = {}) {
         const allocationsCheckpoint = allocations.length;
         const boundsCheckpoint = expectedChangedBounds;
         try {
-            if (operation.kind === 'create_world')
-                diagnostics.push(...applyCreateWorld(base, changes, operation, context));
+            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 === 'update_state')
@@ -3571,6 +3840,7 @@ function* planMapOperationSteps(base, operations, signal, context = {}) {
         ...(expectedChangedBounds === undefined ? {} : { expectedChangedBounds }),
         finalIndex,
         operations: manifestOperations,
+        ...(worldOutputs.length === 0 ? {} : { worldOutputs }),
     };
 }
 export function planMapOperations(base, operations, signal, context = {}) {