hoi4-agent-tools 2.8.2 → 2.8.4

package/CHANGELOG.md

@@ -4,6 +4,16 @@
 
 No unreleased changes.
 
+## 2.8.4 - 2026-08-28
+
+- Render each declared HOI4 font face with its own glyph atlas, native metrics, face colour, border colour, and inherited language-override styling.
+- Keep native HOI4 bitmap or outline glyphs when localisation colour markup changes part of a line instead of replacing the line with the generic tool font.
+
+## 2.8.3 - 2026-08-27
+
+- Centered native button labels when HOI4 GUI source uses `text =` instead of `buttonText =`, matching the in-game horizontal and vertical alignment inside button frames.
+- Added one scenario `values` map for concrete runtime variables, dynamic text, meter fills, sprites, frames, positions, visibility, and enabled states so agents can render complete value-driven GUI versions without assembling several low-level override maps.
+
 ## 2.8.2 - 2026-08-27
 
 - Composed top-level scripted-GUI child windows through `parent_scripted_gui`, instantiated external dynamic-list entry containers, and applied row-scoped image, frame, position, visibility, and enabled values.

package/dist/hoi4_agent_tools/gui/assets.js

@@ -180,6 +180,30 @@ export class GuiAssetCatalog {
                     definition.languages.length === 0))
                 this.fontDefinitions.set(key, definition);
         }
+        const baseDefinitions = new Map();
+        for (const definition of graph.fonts) {
+            if (definition.override || definition.languages.length > 0)
+                continue;
+            const key = definition.name.toLocaleLowerCase('en-US');
+            if (!baseDefinitions.has(key))
+                baseDefinitions.set(key, definition);
+        }
+        for (const [key, definition] of this.fontDefinitions) {
+            if (!definition.override)
+                continue;
+            const base = baseDefinitions.get(key);
+            if (base === undefined)
+                continue;
+            this.fontDefinitions.set(key, {
+                ...definition,
+                ...(definition.colour === undefined && base.colour !== undefined
+                    ? { colour: base.colour }
+                    : {}),
+                ...(definition.borderColour === undefined && base.borderColour !== undefined
+                    ? { borderColour: base.borderColour }
+                    : {}),
+            });
+        }
     }
     resolveFile(assetPath, relativeTo) {
         const normalized = normalizeAssetPath(assetPath);

package/dist/hoi4_agent_tools/gui/layout.js

@@ -218,6 +218,8 @@ function resolveTokenText(value, scenario, localisation, rowValues) {
         const shortKey = key.slice(key.lastIndexOf('.') + 1);
         const replacement = rowValues?.[key] ??
             rowValues?.[shortKey] ??
+            scenario.values[key] ??
+            scenario.values[shortKey] ??
             scenario.variables[key] ??
             scenario.variables[shortKey] ??
             scenario.scriptedGui[key] ??
@@ -235,7 +237,10 @@ function resolveTokenText(value, scenario, localisation, rowValues) {
         if (key === 'X' || key === 'dynamic_loc')
             return match[0];
         const countryKey = key.replace(/^(?:ROOT|This)\./u, '');
-        const replacement = rowValues?.[countryKey] ??
+        const replacement = rowValues?.[key] ??
+            rowValues?.[countryKey] ??
+            scenario.values[key] ??
+            scenario.values[countryKey] ??
             scenario.country?.[countryKey] ??
             scenario.stateValues?.[countryKey] ??
             scenario.scriptedGui[key];
@@ -247,6 +252,15 @@ function resolveTokenText(value, scenario, localisation, rowValues) {
     }, 'GUI scope substitution');
     return { text, unresolved: [...new Set(unresolved)].sort(), missingLocalisation };
 }
+function scenarioExpressionValue(expression, values) {
+    if (typeof expression !== 'string')
+        return undefined;
+    const variableMatch = /^\[\?([^\]|]+)(?:\|[^\]]+)?\]$/u.exec(expression);
+    const localisationMatch = /^\[([^\]]+)\]$/u.exec(expression);
+    const token = variableMatch?.[1] ?? localisationMatch?.[1] ?? expression;
+    const shortToken = token.slice(token.lastIndexOf('.') + 1);
+    return values[token] ?? values[shortToken];
+}
 function measureTextWithInlineIcons(catalog, fontName, text, fontSize, inlineIcons) {
     if (inlineIcons.size === 0 || ![...inlineIcons.keys()].some((marker) => text.includes(marker)))
         return catalog.measureText(fontName, text, fontSize);
@@ -432,7 +446,7 @@ function wrapText(catalog, fontName, text, colours, fontSize, maximumWidth, work
         missingGlyphs: [...missingGlyphs].sort((a, b) => a - b),
     };
 }
-function colourRunsForLine(catalog, fontName, line, colours, fontSize, work, inlineIcons = new Map()) {
+function colourRunsForLine(catalog, fontName, line, colours, fontSize, work, inlineIcons = new Map(), defaultColour = defaultTextColour) {
     if (!colours.some((colour) => colour !== undefined) || line.length === 0)
         return [];
     const runs = [];
@@ -445,11 +459,11 @@ function colourRunsForLine(catalog, fontName, line, colours, fontSize, work, inl
             start += 1;
             continue;
         }
-        const colour = colours[start] ?? defaultTextColour;
+        const colour = colours[start] ?? defaultColour;
         let end = start + 1;
         while (end < line.length &&
             !inlineIcons.has(line[end] ?? '') &&
-            (colours[end] ?? defaultTextColour) === colour)
+            (colours[end] ?? defaultColour) === colour)
             end += 1;
         const text = line.slice(start, end);
         work.spendTextLayout('localisation colour-run measurement');
@@ -465,7 +479,9 @@ function frameFor(element, sprite, scenario, rowValues) {
     const selected = scenario.selectedFrames[element.name] ?? scenario.selectedFrames[sprite.name];
     if (selected !== undefined)
         return Math.min(frameCount - 1, selected);
-    const scriptedFrame = rowValues?.[`${element.name}.frame`] ?? scenario.scriptedGui[`${element.name}.frame`];
+    const scriptedFrame = rowValues?.[`${element.name}.frame`] ??
+        scenario.values[`${element.name}.frame`] ??
+        scenario.scriptedGui[`${element.name}.frame`];
     if (typeof scriptedFrame === 'number' && Number.isFinite(scriptedFrame))
         return Math.min(frameCount - 1, Math.max(0, Math.trunc(scriptedFrame > 0 ? scriptedFrame - 1 : scriptedFrame)));
     const explicit = scalarNumber(property(element.attributes, 'frame'), frameCount);
@@ -600,8 +616,12 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     const scale = parentScale * localScale;
     const position = objectProperty(property(definition.attributes, 'position'));
     const size = objectProperty(property(definition.attributes, 'size'));
-    const scriptedX = rowValues?.[`${definition.name}.x`] ?? scenario.scriptedGui[`${definition.name}.x`];
-    const scriptedY = rowValues?.[`${definition.name}.y`] ?? scenario.scriptedGui[`${definition.name}.y`];
+    const scriptedX = rowValues?.[`${definition.name}.x`] ??
+        scenario.values[`${definition.name}.x`] ??
+        scenario.scriptedGui[`${definition.name}.x`];
+    const scriptedY = rowValues?.[`${definition.name}.y`] ??
+        scenario.values[`${definition.name}.y`] ??
+        scenario.scriptedGui[`${definition.name}.y`];
     const localX = (typeof scriptedX === 'number' && Number.isFinite(scriptedX)
         ? scriptedX * parentScale
         : undefined) ??
@@ -617,6 +637,8 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     const background = objectProperty(property(definition.attributes, 'background'));
     const scriptedImage = rowValues?.[`${definition.name}.image`] ??
         rowValues?.[definition.name] ??
+        scenario.values[`${definition.name}.image`] ??
+        scenario.values[definition.name] ??
         scenario.scriptedGui[`${definition.name}.image`] ??
         scenario.scriptedGui[definition.name];
     const spriteName = (typeof scriptedImage === 'string' && scriptedImage.length > 0 ? scriptedImage : undefined) ??
@@ -706,6 +728,8 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
         addFidelity(fidelity, 'modelled', 'scripted_gui_position', `Scenario properties positioned ${definition.name} at ${localX},${localY} before anchoring.`, definition);
     const rawButtonText = scalarString(property(definition.attributes, 'buttonText'));
     const rawText = scalarString(property(definition.attributes, 'text')) ?? rawButtonText;
+    const embeddedButtonText = rawText !== undefined &&
+        (rawButtonText !== undefined || definition.elementType.toLowerCase().includes('button'));
     let text;
     if (rawText !== undefined) {
         const resolved = resolveTokenText(rawText, scenario, context.localisation, rowValues);
@@ -719,6 +743,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
         displayText = visibleText.text;
         context.work.admitText(displayText, `GUI text for ${definition.name}`);
         const fontName = scalarString(property(definition.attributes, 'font', 'buttonFont'));
+        const fontDefinition = fontName === undefined ? undefined : catalog.fontDefinition(fontName);
         const resolvedFontMetrics = catalog.resolvedFontMetrics(fontName);
         const explicitFontSize = scalarNumber(property(definition.attributes, 'fontSize'), 16);
         const fontSize = explicitFontSize ??
@@ -768,7 +793,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             inlineIcons.push(...shaped.icons);
         }
         const colourRuns = visibleText.hasColourMarkup
-            ? wrapped.lines.map((line, index) => colourRunsForLine(catalog, fontName, line, wrapped.colourLines[index] ?? [], fontSize * scale, context.work, resolvedInlineIcons))
+            ? wrapped.lines.map((line, index) => colourRunsForLine(catalog, fontName, line, wrapped.colourLines[index] ?? [], fontSize * scale, context.work, resolvedInlineIcons, fontDefinition?.colour ?? defaultTextColour))
             : undefined;
         const maximumLineWidth = wrapped.widths.reduce((maximum, value) => Math.max(maximum, value), 0);
         if (width === 0)
@@ -786,8 +811,12 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             measuredWidth,
             measuredHeight,
             metricSource: wrapped.metricSource,
-            ...alignment(definition.attributes, rawButtonText !== undefined),
+            ...alignment(definition.attributes, embeddedButtonText),
             ...(fontName === undefined ? {} : { fontName }),
+            ...(fontDefinition?.colour === undefined ? {} : { colour: fontDefinition.colour }),
+            ...(fontDefinition?.borderColour === undefined
+                ? {}
+                : { borderColour: fontDefinition.borderColour }),
             glyphLines,
             overflowX: width > 0 && measuredWidth > width + 0.01,
             overflowY: height > 0 && measuredHeight > height + 0.01,
@@ -800,6 +829,8 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             addFidelity(fidelity, 'approximated', 'font_metrics', `No supplied font metrics for ${fontName ?? '<default>'}.`, definition);
         else
             addFidelity(fidelity, 'modelled', 'font_metrics', `${wrapped.metricSource} metrics for ${fontName ?? '<default>'}.`, definition);
+        if (fontDefinition?.colour !== undefined || fontDefinition?.borderColour !== undefined)
+            addFidelity(fidelity, 'modelled', 'font_definition_style', `Font ${fontDefinition.name} uses its declared face and colour styling.`, definition);
         const missingGlyphs = [
             ...new Set([...wrapped.missingGlyphs, ...glyphLines.flatMap((line) => line.missingGlyphs)]),
         ].slice(0, GUI_TEXT_MAX_MISSING_GLYPH_SAMPLES);
@@ -845,7 +876,9 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     const clipRect = inheritedClip;
     const clipped = clipRect !== undefined &&
         (availableClip === undefined || !equalRect(unclippedRect, availableClip));
-    const scriptedVisible = rowValues?.[`${definition.name}.visible`] ?? scenario.scriptedGui[`${definition.name}.visible`];
+    const scriptedVisible = rowValues?.[`${definition.name}.visible`] ??
+        scenario.values[`${definition.name}.visible`] ??
+        scenario.scriptedGui[`${definition.name}.visible`];
     const explicitlyVisible = scenario.visibility[definition.name] ??
         scenario.visibility[definition.id] ??
         (typeof scriptedVisible === 'boolean' ? scriptedVisible : undefined);
@@ -853,6 +886,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
         (explicitlyVisible ?? (availableClip !== undefined || inheritedClip === undefined));
     const clickThrough = scalarBoolean(property(definition.attributes, 'clickThrough', 'alwaystransparent', 'allwaystransparent')) ?? false;
     const scriptedEnabled = rowValues?.[`${definition.name}.enabled`] ??
+        scenario.values[`${definition.name}.enabled`] ??
         scenario.scriptedGui[`${definition.name}.enabled`] ??
         context.constantElementEnabled[definition.name];
     const clickable = clickableTypes.test(definition.elementType) && !clickThrough && scriptedEnabled !== false;
@@ -862,7 +896,15 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     if (/progressbar/iu.test(definition.elementType)) {
         const minimum = scalarNumber(property(definition.attributes, 'minValue'), 1) ?? 0;
         const maximum = scalarNumber(property(definition.attributes, 'maxValue'), 1) ?? 100;
-        const scriptedValue = rowValues?.[definition.name] ?? scenario.scriptedGui[definition.name];
+        const startValueToken = scalarString(property(definition.attributes, 'startValue'));
+        const shortStartValueToken = startValueToken?.slice(startValueToken.lastIndexOf('.') + 1);
+        const scriptedValue = rowValues?.[definition.name] ??
+            scenario.values[definition.name] ??
+            (startValueToken === undefined ? undefined : scenario.values[startValueToken]) ??
+            (shortStartValueToken === undefined ? undefined : scenario.values[shortStartValueToken]) ??
+            (startValueToken === undefined ? undefined : scenario.variables[startValueToken]) ??
+            (shortStartValueToken === undefined ? undefined : scenario.variables[shortStartValueToken]) ??
+            scenario.scriptedGui[definition.name];
         let value = typeof scriptedValue === 'number'
             ? scriptedValue
             : (scalarNumber(property(definition.attributes, 'startValue'), maximum) ?? minimum);
@@ -1085,10 +1127,25 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
     const scriptedWindowVisibility = {};
     const constantElementVisibility = {};
     const constantElementEnabled = {};
+    const resolvedScriptedProperties = {};
     const dynamicListsByName = new Map();
     for (const scripted of graph.scriptedGuis.filter(({ name }) => relevantScriptedGuiNames.has(name))) {
         for (const dynamicList of scripted.dynamicListDefinitions)
             dynamicListsByName.set(dynamicList.name, dynamicList);
+        for (const propertyDefinition of scripted.propertyDefinitions) {
+            for (const [attribute, expression] of Object.entries(propertyDefinition.attributes)) {
+                const suffix = attribute.toLowerCase();
+                if (!['image', 'frame', 'x', 'y', 'visible', 'enabled'].includes(suffix))
+                    continue;
+                const resolved = scenarioExpressionValue(expression, scenario.values);
+                if (resolved === undefined)
+                    continue;
+                const key = `${propertyDefinition.elementName}.${suffix}`;
+                if (scenario.values[key] === undefined)
+                    resolvedScriptedProperties[key] = resolved;
+                addFidelity(fidelity, 'modelled', 'scripted_gui_scenario_property', `${key} resolved from a scenario runtime value.`);
+            }
+        }
         for (const trigger of scripted.triggerDefinitions) {
             if (trigger.constantResult === undefined)
                 continue;
@@ -1101,7 +1158,9 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
         addFidelity(fidelity, 'modelled', 'scripted_gui_context', `${scripted.name} uses ${scripted.contextType ?? '<unspecified>'} context.`);
         if (scripted.visibleExpression === undefined)
             continue;
-        const mockedVisibility = scenario.visibility[scripted.name] ?? scenario.scriptedGui[`${scripted.name}.visible`];
+        const mockedVisibility = scenario.visibility[scripted.name] ??
+            scenario.values[`${scripted.name}.visible`] ??
+            scenario.scriptedGui[`${scripted.name}.visible`];
         if (typeof mockedVisibility === 'boolean') {
             if (scripted.windowName !== undefined)
                 scriptedWindowVisibility[scripted.windowName] =
@@ -1114,6 +1173,10 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
     }
     const layoutScenario = {
         ...scenario,
+        values: {
+            ...resolvedScriptedProperties,
+            ...scenario.values,
+        },
         visibility: {
             ...scriptedWindowVisibility,
             ...constantElementVisibility,

package/dist/hoi4_agent_tools/gui/renderer.js

@@ -62,6 +62,31 @@ function sceneGlyphDefinitions(scene) {
             .map(([key, glyph]) => `<image id="${bitmapDefinitionId(key)}" width="${finite(glyph.width)}" height="${finite(glyph.height)}" href="${glyph.dataUri}" preserveAspectRatio="none"/>`),
     ].join('');
 }
+function colourMatrix(colour) {
+    const match = /^#([0-9a-f]{6})([0-9a-f]{2})?$/iu.exec(colour);
+    if (match === null)
+        return '1 0 0 0 0 0 1 0 0 0 0 0 1 0 0 0 0 0 1 0';
+    const rgb = match[1];
+    const alpha = match[2] ?? 'ff';
+    const component = (offset) => Number.parseInt(rgb.slice(offset, offset + 2), 16) / 255;
+    return `${finite(component(0))} 0 0 0 0 0 ${finite(component(2))} 0 0 0 0 0 ${finite(component(4))} 0 0 0 0 0 ${finite(Number.parseInt(alpha, 16) / 255)} 0`;
+}
+function bitmapTintDefinition(id, colour) {
+    return `<filter id="${id}" color-interpolation-filters="sRGB"><feColorMatrix type="matrix" values="${colourMatrix(colour)}"/></filter>`;
+}
+function actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale) {
+    if (glyphLine.source === 'fontkit-path')
+        return glyphLine.glyphs
+            .filter((glyph) => glyph.kind === 'outline')
+            .map((glyph) => `<use href="#${outlineDefinitionId(glyph.key)}" transform="translate(${finite(originX + glyph.x * horizontalScale)} ${finite(baseline + glyph.y)}) scale(${finite(glyph.scale * horizontalScale)} ${finite(-glyph.scale)})"/>`)
+            .join('');
+    if (glyphLine.source === 'bmfont-atlas')
+        return glyphLine.glyphs
+            .filter((glyph) => glyph.kind === 'bitmap')
+            .map((glyph) => `<use href="#${bitmapDefinitionId(glyph.key)}" transform="translate(${finite(originX + glyph.x * horizontalScale)} ${finite(baseline + glyph.y - glyphLine.baseline)}) scale(${finite(horizontalScale)} 1)"/>`)
+            .join('');
+    return '';
+}
 function renderText(element, toolText) {
     const text = element.text;
     if (text === undefined || text.lines.length === 0)
@@ -102,6 +127,25 @@ function renderText(element, toolText) {
         })
             .join('');
         const colourRuns = text.colourRuns?.[index] ?? [];
+        if (colourRuns.length > 0 &&
+            glyphLine !== undefined &&
+            glyphLine.source !== 'deterministic-fallback') {
+            const definitions = [];
+            const renderedRuns = colourRuns.map((run, runIndex) => {
+                const key = `${element.id}:${index}:${runIndex}:${run.colour}`;
+                const clipId = `gui-font-run-clip-${sha256Bytes(key).slice(0, 20)}`;
+                const runX = originX + run.offsetX * horizontalScale;
+                definitions.push(`<clipPath id="${clipId}"><rect x="${finite(runX - 0.25)}" y="${finite(lineTop)}" width="${finite(run.width * horizontalScale + 0.5)}" height="${finite(text.lineHeight)}"/></clipPath>`);
+                const glyphs = actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale);
+                if (glyphLine.source === 'bmfont-atlas') {
+                    const filterId = `gui-font-tint-${sha256Bytes(key).slice(0, 20)}`;
+                    definitions.push(bitmapTintDefinition(filterId, run.colour));
+                    return `<g clip-path="url(#${clipId})" filter="url(#${filterId})" data-font-colour="${run.colour}">${glyphs}</g>`;
+                }
+                return `<g clip-path="url(#${clipId})" fill="${run.colour}" stroke="${text.borderColour ?? '#12151a'}" data-font-colour="${run.colour}">${glyphs}</g>`;
+            });
+            return `<g data-hoi4-colour-runs="true" data-font-sha256="${glyphLine.sourceHash}"><defs>${definitions.join('')}</defs>${renderedRuns.join('')}${inlineIconMarkup}</g>`;
+        }
         if (colourRuns.length > 0) {
             return `<g data-hoi4-colour-runs="true">${colourRuns
                 .map((run) => toolText.render(run.text, {
@@ -109,31 +153,29 @@ function renderText(element, toolText) {
                 y: baseline,
                 fontSize: text.fontSize,
                 fill: run.colour,
-                stroke: '#12151a',
+                stroke: text.borderColour ?? '#12151a',
                 strokeWidth: 0.6,
                 ...(run.width > 0 ? { targetWidth: run.width * horizontalScale } : {}),
             }))
                 .join('')}${inlineIconMarkup}</g>`;
         }
         if (glyphLine?.source === 'fontkit-path') {
-            return `<g data-font-sha256="${glyphLine.sourceHash}">${glyphLine.glyphs
-                .filter((glyph) => glyph.kind === 'outline')
-                .map((glyph) => `<use href="#${outlineDefinitionId(glyph.key)}" transform="translate(${finite(originX + glyph.x * horizontalScale)} ${finite(baseline + glyph.y)}) scale(${finite(glyph.scale * horizontalScale)} ${finite(-glyph.scale)})"/>`)
-                .join('')}${inlineIconMarkup}</g>`;
+            return `<g data-font-sha256="${glyphLine.sourceHash}" fill="${text.colour ?? '#f5f2e8'}" stroke="${text.borderColour ?? '#12151a'}" data-font-colour="${text.colour ?? '#f5f2e8'}">${actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale)}${inlineIconMarkup}</g>`;
         }
         if (glyphLine?.source === 'bmfont-atlas') {
-            return `<g data-font-sha256="${glyphLine.sourceHash}">${glyphLine.glyphs
-                .filter((glyph) => glyph.kind === 'bitmap')
-                .map((glyph) => `<use href="#${bitmapDefinitionId(glyph.key)}" transform="translate(${finite(originX + glyph.x * horizontalScale)} ${finite(baseline + glyph.y - glyphLine.baseline)}) scale(${finite(horizontalScale)} 1)"/>`)
-                .join('')}${inlineIconMarkup}</g>`;
+            const glyphs = actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale);
+            if (text.colour === undefined)
+                return `<g data-font-sha256="${glyphLine.sourceHash}">${glyphs}${inlineIconMarkup}</g>`;
+            const filterId = `gui-font-tint-${sha256Bytes(`${element.id}:${index}:${text.colour}`).slice(0, 20)}`;
+            return `<g data-font-sha256="${glyphLine.sourceHash}" data-font-colour="${text.colour}"><defs>${bitmapTintDefinition(filterId, text.colour)}</defs><g filter="url(#${filterId})">${glyphs}</g>${inlineIconMarkup}</g>`;
         }
         const visibleLine = line.replace(/[\uE000-\uF8FF]/gu, ' ');
         return `<g>${toolText.render(visibleLine, {
             x: originX,
             y: baseline,
             fontSize: text.fontSize,
-            fill: '#f5f2e8',
-            stroke: '#12151a',
+            fill: text.colour ?? '#f5f2e8',
+            stroke: text.borderColour ?? '#12151a',
             strokeWidth: 0.6,
             ...(width > 0 ? { targetWidth: width } : {}),
         })}${inlineIconMarkup}</g>`;

package/dist/hoi4_agent_tools/gui/scenario.js

@@ -118,6 +118,7 @@ const GuiPreviewScenarioBodySchema = z
     flags: z.record(z.string(), z.boolean()).default({}),
     lists: z.record(z.string(), z.array(objectSchema).max(10_000)).default({}),
     localisation: z.record(z.string(), z.string()).default({}),
+    values: objectSchema.default({}),
     scriptedGui: objectSchema.default({}),
     visibility: z.record(z.string(), z.boolean()).default({}),
     elementStates: z.record(z.string(), previewStateSchema).default({}),

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

@@ -188,6 +188,15 @@ function boolScalar(block, ...keys) {
         return false;
     return undefined;
 }
+function paradoxColour(value) {
+    if (value === undefined)
+        return undefined;
+    const match = /^0x([0-9a-f]{8})$/iu.exec(value.trim());
+    if (match === null)
+        return undefined;
+    const argb = match[1];
+    return `#${argb.slice(2)}${argb.slice(0, 2)}`.toLowerCase();
+}
 function sizeFrom(block) {
     const size = childBlocks(block, 'size')[0];
     if (size === undefined)
@@ -425,6 +434,8 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                     const languages = childBlocks(child, 'languages').flatMap((languageBlock) => languageBlock.entries
                         .filter((entry) => entry.type === 'scalar')
                         .map((entry) => entry.value));
+                    const colour = paradoxColour(firstScalarInsensitive(child, 'color', 'colour'));
+                    const borderColour = paradoxColour(firstScalarInsensitive(child, 'border_color', 'borderColor', 'border_colour'));
                     const id = deterministicId('gui_font', { path: file.displayPath, name });
                     const font = {
                         id,
@@ -435,6 +446,8 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                         override: assignment.key.value === 'bitmapfont_override',
                         languages,
                         assetPaths,
+                        ...(colour === undefined ? {} : { colour }),
+                        ...(borderColour === undefined ? {} : { borderColour }),
                         rawSource: raw(document, assignment),
                     };
                     addDomainEntry(fonts, font, 'font');
@@ -449,6 +462,8 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                             override: font.override,
                             languages,
                             assetPaths,
+                            ...(colour === undefined ? {} : { colour }),
+                            ...(borderColour === undefined ? {} : { borderColour }),
                         },
                     });
                     addEdge(edges, 'contains', fileNodeId, id, true, {}, font.location);
@@ -531,7 +546,16 @@ function indexScriptedGuis(document, file, fileNodeId, nodes, edges, scriptedGui
                 };
             });
             const triggers = triggerDefinitions.map(({ name: trigger }) => trigger);
-            const properties = namedAssignments(block, 'properties').map(({ key }) => key.value);
+            const propertyAssignments = namedAssignments(block, 'properties');
+            const properties = propertyAssignments.map(({ key }) => key.value);
+            const propertyDefinitions = propertyAssignments.map((property) => ({
+                elementName: property.key.value,
+                attributes: property.value.type === 'block'
+                    ? sourceValueToProperty(property.value, constantsFor(document))
+                    : {},
+                rawSource: raw(document, property),
+                location: nodeLocation(document, property, property.key.value),
+            }));
             const dynamicListDefinitions = namedAssignments(block, 'dynamic_lists').map((dynamicList) => {
                 const entryContainer = dynamicList.value.type === 'block'
                     ? firstScalarInsensitive(dynamicList.value, 'entry_container')
@@ -571,6 +595,7 @@ function indexScriptedGuis(document, file, fileNodeId, nodes, edges, scriptedGui
                 triggers: triggers.sort((a, b) => compareCodeUnits(a, b)),
                 triggerDefinitions: triggerDefinitions.sort((a, b) => compareCodeUnits(a.name, b.name)),
                 properties: properties.sort((a, b) => compareCodeUnits(a, b)),
+                propertyDefinitions: propertyDefinitions.sort((a, b) => compareCodeUnits(a.elementName, b.elementName)),
                 dynamicLists: dynamicLists.sort((a, b) => compareCodeUnits(a, b)),
                 dynamicListDefinitions: dynamicListDefinitions.sort((left, right) => compareCodeUnits(left.name, right.name)),
                 aiWeights: aiWeights.sort((a, b) => compareCodeUnits(a, b)),

package/dist/hoi4_agent_tools/gui/studio.js

@@ -379,7 +379,7 @@ function referencedAssetPatternsForWindow(graph, windowName, additionalSpriteNam
 }
 function scenarioSpriteNames(scenarios) {
     return [
-        ...new Set(scenarios.flatMap(({ scriptedGui }) => Object.entries(scriptedGui)
+        ...new Set(scenarios.flatMap(({ values, scriptedGui }) => Object.entries({ ...scriptedGui, ...values })
             .filter(([key, value]) => typeof value === 'string' &&
             value.startsWith('GFX_') &&
             (key.endsWith('.image') || !key.includes('.')))

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.2';
+export const PACKAGE_VERSION = '2.8.4';
 export const MCP_PROTOCOL_VERSION = LATEST_PROTOCOL_VERSION;
 export const CONFIG_VERSION = 1;
 export const TRANSACTION_VERSION = 1;

package/docs/gui.md

@@ -33,17 +33,23 @@ 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. 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, and language override. HOI4 localisation colour runs such as `§Y` and `§R` recolour those same native glyphs 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.
 
 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. Scenario properties can select an element image or frame, move it with `.x` and `.y`, and control `.visible` or `.enabled` values. 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.
+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.
 
 Preview scenarios can include exact layout expectations:
 
 ```json
 {
   "id": "populated-unlocked",
+  "values": {
+    "threat": 73,
+    "GetThreatLabel": "High",
+    "threat_meter": 73,
+    "confirm_button.enabled": true
+  },
   "flags": { "panel_open": true },
   "lists": { "target_list": [{ "id": 1, "label": "First target" }] },
   "visibility": { "target_list": true, "confirm_button": true },
@@ -68,6 +74,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.
 
-Unresolved numeric runtime values such as `[?variable|format]` render as `[X]`. Unresolved text-returning scripted or scoped localisation such as `[GetStatusText]`, `[FROM.GetName]`, and `[?leader_scope.GetName]` renders as `[dynamic_loc]`. Provide scenario values when the exact value matters. Supported HOI4 `§` localisation colour controls are applied to preview text and `§!` restores the default colour.
+Unresolved numeric runtime values such as `[?variable|format]` render as `[X]`. Unresolved text-returning scripted or scoped localisation such as `[GetStatusText]`, `[FROM.GetName]`, and `[?leader_scope.GetName]` renders as `[dynamic_loc]`. Put `variable` or `GetStatusText` in the scenario's `values` object when the exact value matters; the same scenario can set the related meter or state-dependent controls. Supported HOI4 `§` localisation colour controls are applied to preview text and `§!` restores the default 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.2",
+  "version": "2.8.4",
   "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.2/schemas/configuration.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/continuous-focus-palette.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/custom-weighted-pool.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/event-feature-manifest.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/focus-plan.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/focus-planning-sidecar.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/gui-animation-source.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/gui-helper.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/gui-scenario.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/schemas/gui-scenario.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {
@@ -45,29 +45,32 @@
     "localisation": {
       "$ref": "#/$defs/__schema17"
     },
-    "scriptedGui": {
+    "values": {
       "$ref": "#/$defs/__schema18"
     },
-    "visibility": {
+    "scriptedGui": {
       "$ref": "#/$defs/__schema19"
     },
-    "elementStates": {
+    "visibility": {
       "$ref": "#/$defs/__schema20"
     },
-    "selectedFrames": {
+    "elementStates": {
       "$ref": "#/$defs/__schema21"
     },
-    "scrollOffsets": {
+    "selectedFrames": {
       "$ref": "#/$defs/__schema22"
     },
-    "guiCosts": {
+    "scrollOffsets": {
       "$ref": "#/$defs/__schema23"
     },
-    "scriptCosts": {
+    "guiCosts": {
       "$ref": "#/$defs/__schema24"
     },
-    "expectations": {
+    "scriptCosts": {
       "$ref": "#/$defs/__schema25"
+    },
+    "expectations": {
+      "$ref": "#/$defs/__schema26"
     }
   },
   "required": [
@@ -235,6 +238,10 @@
       "$ref": "#/$defs/__schema12"
     },
     "__schema19": {
+      "default": {},
+      "$ref": "#/$defs/__schema12"
+    },
+    "__schema20": {
       "default": {},
       "type": "object",
       "propertyNames": {
@@ -244,7 +251,7 @@
         "type": "boolean"
       }
     },
-    "__schema20": {
+    "__schema21": {
       "default": {},
       "type": "object",
       "propertyNames": {
@@ -254,7 +261,7 @@
         "$ref": "#/$defs/__schema7"
       }
     },
-    "__schema21": {
+    "__schema22": {
       "default": {},
       "type": "object",
       "propertyNames": {
@@ -266,7 +273,7 @@
         "maximum": 9007199254740991
       }
     },
-    "__schema22": {
+    "__schema23": {
       "default": {},
       "type": "object",
       "propertyNames": {
@@ -277,7 +284,7 @@
         "minimum": 0
       }
     },
-    "__schema23": {
+    "__schema24": {
       "default": {},
       "type": "object",
       "propertyNames": {
@@ -287,7 +294,7 @@
         "type": "number"
       }
     },
-    "__schema24": {
+    "__schema25": {
       "default": {},
       "type": "object",
       "propertyNames": {
@@ -297,7 +304,7 @@
         "type": "number"
       }
     },
-    "__schema25": {
+    "__schema26": {
       "default": {
         "visible": [],
         "hidden": [],
@@ -311,7 +318,7 @@
           "maxItems": 10000,
           "type": "array",
           "items": {
-            "$ref": "#/$defs/__schema26"
+            "$ref": "#/$defs/__schema27"
           }
         },
         "hidden": {
@@ -319,33 +326,33 @@
           "maxItems": 10000,
           "type": "array",
           "items": {
-            "$ref": "#/$defs/__schema26"
+            "$ref": "#/$defs/__schema27"
           }
         },
         "containedBy": {
           "default": {},
           "type": "object",
           "propertyNames": {
-            "$ref": "#/$defs/__schema26"
+            "$ref": "#/$defs/__schema27"
           },
           "additionalProperties": {
-            "$ref": "#/$defs/__schema26"
+            "$ref": "#/$defs/__schema27"
           }
         },
         "centeredOn": {
           "default": {},
           "type": "object",
           "propertyNames": {
-            "$ref": "#/$defs/__schema26"
+            "$ref": "#/$defs/__schema27"
           },
           "additionalProperties": {
-            "$ref": "#/$defs/__schema26"
+            "$ref": "#/$defs/__schema27"
           }
         }
       },
       "additionalProperties": false
     },
-    "__schema26": {
+    "__schema27": {
       "type": "string",
       "minLength": 1,
       "maxLength": 256

package/schemas/map-operation.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.2/schemas/map-operation.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/operation-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/probability-analysis-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/probability-compare-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/probability-evaluate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/probability-inspect-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/probability-render-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/probability-scenario-set.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/probability-sequence-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/probability-simulate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2/schemas/probability-sweep-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.4/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.2",
+  "version": "2.8.4",
   "repository": {
     "url": "https://github.com/klimPaskov/hoi4-agent-tools",
     "source": "github"
@@ -13,7 +13,7 @@
     {
       "registryType": "npm",
       "identifier": "hoi4-agent-tools",
-      "version": "2.8.2",
+      "version": "2.8.4",
       "transport": {
         "type": "stdio"
       }