hoi4-agent-tools 2.8.5 → 2.8.7

package/dist/hoi4_agent_tools/gui/source-graph.js

@@ -117,7 +117,27 @@ export function guiElementAttributeFidelity(key) {
     return 'unsupported';
 }
 function normalizeAssetPath(value) {
-    return value.replaceAll('\\', '/').replace(/^\.\//u, '').replace(/^\//u, '').toLowerCase();
+    return value
+        .replaceAll('\\', '/')
+        .replace(/^\/+|^\.\//u, '')
+        .replace(/\/+/gu, '/')
+        .toLowerCase();
+}
+function textureNodeFor(textureNodes, texturePath) {
+    const normalized = normalizeAssetPath(texturePath);
+    const extension = path.posix.extname(normalized);
+    const rasterExtensions = ['.png', '.bmp', '.tga', '.dds'];
+    const candidates = rasterExtensions.includes(extension)
+        ? [
+            normalized,
+            ...rasterExtensions
+                .filter((candidate) => candidate !== extension)
+                .map((candidate) => `${normalized.slice(0, -extension.length)}${candidate}`),
+        ]
+        : [normalized];
+    return candidates
+        .map((candidate) => textureNodes.get(candidate))
+        .find((value) => value !== undefined);
 }
 function scalarValue(value, constants) {
     const expanded = constants.get(value) ?? value;
@@ -363,7 +383,7 @@ function indexGuiElements(document, file, fileNodeId, nodes, edges, elements) {
         }
     }
 }
-function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites, fonts) {
+function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites, fonts, globalTextColours) {
     const walk = (block) => {
         for (const assignment of assignments(block)) {
             if (assignment.value.type !== 'block')
@@ -457,14 +477,21 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                     const colour = paradoxColour(firstScalarInsensitive(child, 'color', 'colour'));
                     const borderColour = paradoxColour(firstScalarInsensitive(child, 'border_color', 'borderColor', 'border_colour'));
                     const textColours = textColoursFrom(child);
-                    const id = deterministicId('gui_font', { path: file.displayPath, name });
+                    const override = assignment.key.value === 'bitmapfont_override';
+                    const id = deterministicId('gui_font', {
+                        path: file.displayPath,
+                        name,
+                        override,
+                        languages,
+                        assetPaths,
+                    });
                     const font = {
                         id,
                         name,
                         sourcePath: file.displayPath,
                         location: nodeLocation(document, assignment, name),
                         kind: 'bitmapfont',
-                        override: assignment.key.value === 'bitmapfont_override',
+                        override,
                         languages,
                         assetPaths,
                         ...(colour === undefined ? {} : { colour }),
@@ -492,6 +519,9 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                     addEdge(edges, 'contains', fileNodeId, id, true, {}, font.location);
                 }
             }
+            if (assignment.key.value === 'bitmapfonts') {
+                Object.assign(globalTextColours, textColoursFrom(child));
+            }
             walk(child);
         }
     };
@@ -773,8 +803,21 @@ function indexScriptedLocalisation(document, file, fileNodeId, nodes, edges, def
         const name = firstScalar(assignment.value, 'name')?.value;
         if (name === undefined)
             continue;
-        const localisationKeys = childBlocks(assignment.value, 'text')
-            .flatMap((textBlock) => firstScalar(textBlock, 'localisation_key')?.value ?? [])
+        const choices = childBlocks(assignment.value, 'text').flatMap((textBlock) => {
+            const localisationKey = firstScalarInsensitive(textBlock, 'localisation_key', 'localization_key');
+            if (localisationKey === undefined)
+                return [];
+            const trigger = childBlocks(textBlock, 'trigger')[0];
+            return [
+                {
+                    localisationKey,
+                    ...(trigger === undefined ? {} : { triggerExpression: raw(document, trigger) }),
+                    rawSource: raw(document, textBlock),
+                },
+            ];
+        });
+        const localisationKeys = choices
+            .map(({ localisationKey }) => localisationKey)
             .sort((left, right) => compareCodeUnits(left, right));
         const id = deterministicId('scripted_localisation', { path: file.displayPath, name });
         const location = nodeLocation(document, assignment, name);
@@ -784,6 +827,7 @@ function indexScriptedLocalisation(document, file, fileNodeId, nodes, edges, def
             sourcePath: file.displayPath,
             location,
             localisationKeys,
+            choices,
             rawSource: raw(document, assignment),
         }, 'scripted localisation');
         addNode(nodes, {
@@ -792,7 +836,13 @@ function indexScriptedLocalisation(document, file, fileNodeId, nodes, edges, def
             name,
             path: file.displayPath,
             location,
-            metadata: { localisationKeys },
+            metadata: {
+                localisationKeys,
+                choices: choices.map(({ localisationKey, triggerExpression }) => ({
+                    localisationKey,
+                    ...(triggerExpression === undefined ? {} : { triggerExpression }),
+                })),
+            },
         });
         addEdge(edges, 'contains', fileNodeId, id, true, {}, location);
     }
@@ -864,7 +914,7 @@ function linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scripte
         for (const [index, texturePath] of [sprite.texturePath, sprite.texturePath2].entries()) {
             if (texturePath === undefined)
                 continue;
-            const textureId = textureNodes.get(normalizeAssetPath(texturePath));
+            const textureId = textureNodeFor(textureNodes, texturePath);
             addEdge(edges, 'uses_texture', sprite.id, textureId ?? `texture:${normalizeAssetPath(texturePath)}`, textureId !== undefined, { texturePath, slot: index + 1 }, sprite.location);
         }
         const candidates = [
@@ -1069,6 +1119,7 @@ export function buildGuiSourceGraph(files, sharedIndex) {
     const elements = [];
     const sprites = [];
     const fonts = [];
+    const textColours = {};
     const scriptedGuis = [];
     const animationSources = [];
     const scriptedLocalisation = [];
@@ -1190,7 +1241,7 @@ export function buildGuiSourceGraph(files, sharedIndex) {
         if (kind === 'gui_file')
             indexGuiElements(document, file, fileNodeId, nodes, edges, elements);
         if (kind === 'gfx_file') {
-            indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites, fonts);
+            indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites, fonts, textColours);
         }
         if (kind === 'scripted_gui_file') {
             indexScriptedGuis(document, file, fileNodeId, nodes, edges, scriptedGuis);
@@ -1270,6 +1321,7 @@ export function buildGuiSourceGraph(files, sharedIndex) {
         elements,
         sprites,
         fonts,
+        textColours: Object.fromEntries(Object.entries(textColours).sort(([left], [right]) => compareCodeUnits(left, right))),
         scriptedGuis,
         animationSources,
         scriptedLocalisation,

package/dist/hoi4_agent_tools/gui/studio.js

@@ -328,7 +328,7 @@ function localisationIconSpriteCandidates(token) {
     const normalized = token.startsWith('GFX_') ? token : `GFX_${token}`;
     return [...new Set([normalized, `${normalized}_texticon`, `${normalized}_text_icon`])];
 }
-function referencedAssetPatternsForWindow(graph, windowName, additionalSpriteNames = []) {
+export function referencedAssetPatternsForWindow(graph, windowName, additionalSpriteNames = [], languages = ['l_english']) {
     const spriteNames = new Set(additionalSpriteNames);
     const fontNames = new Set();
     const textValues = new Set();
@@ -347,6 +347,37 @@ function referencedAssetPatternsForWindow(graph, windowName, additionalSpriteNam
                 spriteNames.add(candidate);
         }
     }
+    const relatedScriptedGuiNames = new Set(graph.scriptedGuis
+        .filter((definition) => definition.windowName === windowName || definition.parentWindowName === windowName)
+        .map(({ name }) => name));
+    let addedRelatedScriptedGui = true;
+    while (addedRelatedScriptedGui) {
+        addedRelatedScriptedGui = false;
+        for (const definition of graph.scriptedGuis) {
+            if (definition.parentScriptedGui === undefined ||
+                !relatedScriptedGuiNames.has(definition.parentScriptedGui) ||
+                relatedScriptedGuiNames.has(definition.name))
+                continue;
+            relatedScriptedGuiNames.add(definition.name);
+            addedRelatedScriptedGui = true;
+        }
+    }
+    const dynamicImageTokens = new Set(graph.scriptedGuis
+        .filter(({ name }) => relatedScriptedGuiNames.has(name))
+        .flatMap(({ propertyDefinitions }) => propertyDefinitions)
+        .flatMap(({ attributes }) => {
+        const image = Object.entries(attributes).find(([key]) => key.toLocaleLowerCase('en-US') === 'image')?.[1];
+        if (typeof image !== 'string')
+            return [];
+        const match = /^\[([^\]]+)\]$/u.exec(image);
+        return match?.[1] === undefined ? [] : [match[1]];
+    }));
+    for (const definition of graph.scriptedLocalisation) {
+        if (!dynamicImageTokens.has(definition.name))
+            continue;
+        for (const candidate of definition.localisationKeys)
+            spriteNames.add(candidate);
+    }
     const spritesByName = new Map(graph.sprites.map((sprite) => [sprite.name.toLocaleLowerCase('en-US'), sprite]));
     const selectedSprites = new Map();
     const pendingSprites = [...spriteNames];
@@ -366,7 +397,17 @@ function referencedAssetPatternsForWindow(graph, windowName, additionalSpriteNam
     }
     const selectedManifests = graph.animationSources.filter(({ sprite }) => selectedSprites.has(sprite.toLocaleLowerCase('en-US')));
     const selectedFontNames = new Set([...fontNames].map((name) => name.toLocaleLowerCase('en-US')));
-    const selectedFonts = graph.fonts.filter(({ name }) => selectedFontNames.has(name.toLocaleLowerCase('en-US')));
+    const normalizedLanguages = new Set(languages.flatMap((language) => {
+        const normalized = language.toLocaleLowerCase('en-US');
+        return [normalized, normalized.replace(/^l_/u, '')];
+    }));
+    const selectedFonts = graph.fonts.filter(({ name, languages: fontLanguages }) => selectedFontNames.has(name.toLocaleLowerCase('en-US')) &&
+        (fontLanguages.length === 0 ||
+            fontLanguages.some((language) => {
+                const normalized = language.toLocaleLowerCase('en-US');
+                return (normalizedLanguages.has(normalized) ||
+                    normalizedLanguages.has(normalized.replace(/^l_/u, '')));
+            })));
     const references = [
         ...[...selectedSprites.values()].flatMap(({ texturePath, texturePath2 }) => [texturePath, texturePath2].filter((value) => value !== undefined)),
         ...selectedFonts.flatMap(({ assetPaths }) => assetPaths),
@@ -665,7 +706,7 @@ export class ScriptedGuiStudio {
         const definitionFiles = mergeScannedFiles(layoutFiles, linkedDefinitions.files, localisation.files);
         const definitions = this.graphForFiles(definitionFiles, `definitions:${workspaceId}`);
         assertTargetWindowAvailable(definitions.graph, windowName);
-        const referencedPatterns = referencedAssetPatternsForWindow(definitions.graph, windowName, additionalSpriteNames);
+        const referencedPatterns = referencedAssetPatternsForWindow(definitions.graph, windowName, additionalSpriteNames, languages);
         const exactReferenced = referencedPatterns.length === 0
             ? []
             : await this.scanner.scan(workspace, {
@@ -1100,7 +1141,7 @@ export class ScriptedGuiStudio {
             const scenario = parsePreviewScenario(input.scenario);
             const renderBudget = new RenderBudget();
             let proposedGraph = buildGuiSourceGraph(proposedFiles, this.engine.indexFiles(proposedFiles));
-            const proposedAssetPatterns = referencedAssetPatternsForWindow(proposedGraph, input.windowName);
+            const proposedAssetPatterns = referencedAssetPatternsForWindow(proposedGraph, input.windowName, [], [scenario.language]);
             const exactProposedAssets = proposedAssetPatterns.length === 0
                 ? []
                 : await this.scanner.scan(workspace, {

package/dist/hoi4_agent_tools/gui/validators.js

@@ -509,7 +509,12 @@ function validateReferencesAndScript(graph, scene, diagnostics) {
     const selectedSpriteNames = new Set(scene.elements.flatMap(({ sprite }) => (sprite === undefined ? [] : [sprite.spriteName])));
     const selectedSpriteIds = new Set(graph.sprites.filter(({ name }) => selectedSpriteNames.has(name)).map(({ id }) => id));
     const selectedFontNames = new Set(scene.elements.flatMap(({ text }) => (text?.fontName === undefined ? [] : [text.fontName])));
-    const selectedFontIds = new Set(graph.fonts.filter(({ name }) => selectedFontNames.has(name)).map(({ id }) => id));
+    const sceneLanguage = scene.scenario.language.toLocaleLowerCase('en-US');
+    const selectedFontIds = new Set(graph.fonts
+        .filter(({ name, languages }) => selectedFontNames.has(name) &&
+        (languages.length === 0 ||
+            languages.some((language) => language.toLocaleLowerCase('en-US') === sceneLanguage)))
+        .map(({ id }) => id));
     const selectedManifestIds = new Set(graph.animationSources
         .filter(({ sprite }) => selectedSpriteNames.has(sprite))
         .map(({ id }) => id));

package/dist/hoi4_agent_tools/probability/service.js

@@ -735,11 +735,12 @@ export class ProbabilityAnalyzer {
     }
     async store(result, outputs, includeHtml = false, signal, principal) {
         const cached = this.state.byCacheKey.get(result.metadata.cacheKey);
+        const workspace = this.engine.resolver.get(result.metadata.workspaceId, principal);
         if (cached?.operation === result.operation &&
             cached.status === result.status &&
-            visualOutputs(outputs).length === 0)
+            visualOutputs(outputs).length === 0 &&
+            (await this.engine.artifacts.available(workspace, cached.resources, signal)))
             return cached;
-        const workspace = this.engine.resolver.get(result.metadata.workspaceId, principal);
         const provenance = {
             kind: 'probability-analysis',
             toolVersion: PACKAGE_VERSION,

package/dist/hoi4_agent_tools/version.js

@@ -1,6 +1,6 @@
 import { LATEST_PROTOCOL_VERSION } from '@modelcontextprotocol/sdk/types.js';
 export const PACKAGE_NAME = 'hoi4-agent-tools';
-export const PACKAGE_VERSION = '2.8.5';
+export const PACKAGE_VERSION = '2.8.7';
 export const MCP_PROTOCOL_VERSION = LATEST_PROTOCOL_VERSION;
 export const CONFIG_VERSION = 1;
 export const TRANSACTION_VERSION = 1;

package/docs/gui.md

@@ -33,15 +33,15 @@ Inspection checks missing assets and localisation, invalid sizes, overlap, clipp
 
 The renderer resolves sprites and fonts through the complete mod, dependency, and installed-game load order. Mod windows therefore render ordinary vanilla sprites, tiled vanilla panels, progress bars, masked shields, button frames, and localisation icons such as `£command_power` without copying game assets into the mod. Case differences in GFX and font identifiers do not prevent a valid asset from resolving.
 
-Bitmap text uses the language-appropriate HOI4 font definition and its real glyph atlas. Header, serif, compact, typewriter, black, inverted, and other declared faces keep their own glyph shapes, native metrics, face colour, border colour, language override, and font-specific `textcolors` palette. HOI4 localisation colour runs such as `§Y` and `§R` tint those same native glyph masks with the exact palette colour instead of switching to the tool font. The default language uses the base font rather than an unrelated language override, and the renderer recognizes installed-game atlases whose filename omits a page suffix declared by the matching `.fnt` file.
+Bitmap text uses the language-appropriate HOI4 font definition and its real glyph atlas. Header, serif, compact, typewriter, black, inverted, and other declared faces keep their own glyph shapes, native metrics, face colour, border colour, language override, and font-specific `textcolors` palette. HOI4 localisation colour runs such as `§Y` and `§R` multiply the selected palette colour into the native glyph pixels, preserving the atlas's sharp antialiasing and dark shadow pixels instead of flattening the glyph into a blurred monochrome mask or switching to the tool font. The default language uses the base font rather than an unrelated language override, and the renderer recognizes installed-game atlases whose filename omits a page suffix declared by the matching `.fnt` file.
 
 Layout follows Clausewitz orientation and element-origin anchors, including `CENTER_LEFT`, `CENTER_RIGHT`, `CENTER_UP`, `CENTER_DOWN`, `origo`, `centerposition`, inherited container coordinate origins, local scale, and both `%` and `%%` relative dimensions. Text boxes use native font metrics together with `maxWidth`, `maxHeight`, alignment, wrapping, and `fixedsize` clipping. Cornered tile sprites use fixed nine-slice borders and optional center tiling; progress bars composite their filled and background textures; masked shields composite their background and mask textures.
 
 Scripted-GUI composition follows `parent_scripted_gui` chains even when the linked child window is a top-level sibling in the `.gui` file. Literal `always = yes` and `always = no` visibility and click-enabled blocks are applied automatically. A scenario's `values` object supplies concrete runtime values in one place: variable names resolve numeric text, scripted-localisation names resolve dynamic labels, a progress-bar element name sets its fill value, and element keys ending in `.image`, `.frame`, `.x`, `.y`, `.visible`, or `.enabled` update that visual property. Scripted-GUI property expressions such as `image = "[GetMeterSprite]"` or `x = meter_fill_width` consume matching scenario values automatically. Dynamic lists instantiate their declared `entry_container` or `country_scope_entry_container`; each scenario row can select the country template with `countryScope`, choose an explicit `entryContainer`, and provide row-scoped text, image, frame, position, visibility, and enabled values.
 
-`hoi4.gui_inspect` and `hoi4.gui_render` generate a plausible seeded runtime scenario by default. The generator discovers numeric and text tokens in the selected window, localisation, and scripted-GUI properties; fills meters; populates dynamic lists; chooses animated frames; varies condition-controlled visibility and enabled controls; and leaves values explicitly supplied by the caller unchanged. The same artifact gallery retains the unresolved placeholder scenario and every explicit `relatedScenarios` entry, so an agent can compare plausible data, exact authored cases, and `[dynamic_loc]` or `[X]` fallbacks in one result.
+`hoi4.gui_inspect` and `hoi4.gui_render` generate a plausible seeded runtime scenario by default. The generator follows the complete `parent_scripted_gui` surface, discovers numeric and text tokens in GUI localisation and scripted-GUI properties, chooses real scripted-localisation text and sprite candidates, applies simple source thresholds, fills meters within their declared ranges, populates dynamic lists with coherent rows, selects one overlapping tab pane, keeps active and idle controls mutually exclusive, and leaves values explicitly supplied by the caller unchanged. Normal controls and animation frames remain stable unless variation is explicitly requested. Every explicit `relatedScenarios` entry is rendered beside the generated view.
 
-Generation is reproducible. Set `generatedScenarios.seed` to any stable string for an exact rerun, use `count` for several plausible versions, or configure numeric bounds, integer or decimal values, list row bounds, text samples, visibility probability, and state variation. Set `enabled` to `false` when only the supplied scenario should render, and set `preservePlaceholder` to `false` when the fallback view is not needed.
+Generation is reproducible. Set `generatedScenarios.seed` to any stable string for an exact rerun, use `count` for several plausible versions, or configure numeric bounds, integer or decimal values, list row bounds, text samples, visibility probability, and state variation. The generated view is the default. Set `enabled` to `false` when only the supplied placeholder scenario should render, or set `preservePlaceholder` to `true` to include the placeholder beside generated scenarios.
 
 ```json
 {
@@ -93,6 +93,6 @@ Large inspections, renders, and rewrites send periodic MCP progress heartbeats w
 
 The renderer does not run the game engine. Each render includes a fidelity report that separates fields it models from fields it approximates, ignores, cannot resolve, or does not support. Treat that report as part of the review.
 
-The generated primary view replaces discovered numeric and text runtime tokens with plausible values. The retained fallback view renders unresolved numeric values such as `[?variable|format]` as `[X]` and unresolved text-returning scripted or scoped localisation such as `[GetStatusText]`, `[FROM.GetName]`, and `[?leader_scope.GetName]` as `[dynamic_loc]`. Put `variable` or `GetStatusText` in the supplied scenario's `values` object when an exact value matters; explicit values always take precedence over generated ones and can drive the related meter or state-dependent controls. Supported HOI4 `§` localisation colour controls use the active font's palette and `§!` restores the face colour.
+The generated primary view replaces discovered numeric and text runtime tokens with plausible values. Set `generatedScenarios.preservePlaceholder` to `true`, or disable generation, when the same run should also show unresolved numeric values such as `[?variable|format]` as `[X]` and unresolved text-returning scripted or scoped localisation such as `[GetStatusText]`, `[FROM.GetName]`, and `[?leader_scope.GetName]` as `[dynamic_loc]`. Put `variable` or `GetStatusText` in the supplied scenario's `values` object when an exact value matters; explicit values always take precedence over generated ones and can drive the related meter or state-dependent controls. Supported HOI4 `§` localisation colour controls use the active font's palette and `§!` restores the face colour.
 
 A rewrite stops if malformed or unsupported GUI script makes the requested change ambiguous. Frame-sheet animation, nine-slice tiling, progress composition, masking, and the primary and secondary textures referenced by vanilla GFX definitions render offline. Engine shader programs, hardcoded controls, and dynamic values that are not supplied by a scenario remain fidelity-report entries; an unexecuted shader never hides its resolved base texture.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hoi4-agent-tools",
   "mcpName": "io.github.klimPaskov/hoi4-agent-tools",
-  "version": "2.8.5",
+  "version": "2.8.7",
   "description": "Analyze HOI4 events, tech trees, AI weights, and MTTH; build focus trees, GUIs, and maps.",
   "type": "module",
   "license": "Apache-2.0",

package/schemas/configuration.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/configuration.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/configuration.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/continuous-focus-palette.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/continuous-focus-palette.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/continuous-focus-palette.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/custom-weighted-pool.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/custom-weighted-pool.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/custom-weighted-pool.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/event-feature-manifest.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/event-feature-manifest.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/event-feature-manifest.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/focus-plan.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/focus-plan.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/focus-plan.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/focus-planning-sidecar.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/focus-planning-sidecar.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/focus-planning-sidecar.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/gui-animation-source.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/gui-animation-source.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/gui-animation-source.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/gui-helper.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/gui-helper.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/gui-helper.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/gui-scenario.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/gui-scenario.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/gui-scenario.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/map-operation.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/map-operation.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/map-operation.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "oneOf": [
     {

package/schemas/operation-result.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/operation-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/operation-result.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-analysis-result.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/probability-analysis-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/probability-analysis-result.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-compare-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/probability-compare-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/probability-compare-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-evaluate-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/probability-evaluate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/probability-evaluate-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-inspect-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/probability-inspect-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/probability-inspect-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-render-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/probability-render-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/probability-render-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-scenario-set.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/probability-scenario-set.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/probability-scenario-set.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-sequence-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/probability-sequence-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/probability-sequence-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-simulate-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/probability-simulate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/probability-simulate-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/probability-sweep-input.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.5/schemas/probability-sweep-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.7/schemas/probability-sweep-input.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.klimPaskov/hoi4-agent-tools",
   "title": "HOI4 Agent Tools",
   "description": "Analyze HOI4 events, tech trees, AI weights, and MTTH; build focus trees, GUIs, and maps.",
-  "version": "2.8.5",
+  "version": "2.8.7",
   "repository": {
     "url": "https://github.com/klimPaskov/hoi4-agent-tools",
     "source": "github"
@@ -13,7 +13,7 @@
     {
       "registryType": "npm",
       "identifier": "hoi4-agent-tools",
-      "version": "2.8.5",
+      "version": "2.8.7",
       "transport": {
         "type": "stdio"
       }