hoi4-agent-tools 2.8.7 → 2.8.9

package/CHANGELOG.md

@@ -4,6 +4,17 @@
 
 No unreleased changes.
 
+## 2.8.9 - 2026-08-29
+
+- Decode BMFont channel roles so installed HOI4 atlases render their face and outline masks separately instead of losing localisation colours.
+- Infer black-on-white and white-on-transparent glyph-mask polarity, preserving support for both vanilla fonts and custom mod fonts.
+
+## 2.8.8 - 2026-08-29
+
+- Correct GUI font selection so mod definitions override lower-load-order game definitions, language-specific overrides only apply to their language, and extensionless WOFF assets resolve.
+- Accept numeric-block and six-digit Paradox colors, normalize fractional text-color channels, and place color runs from kerning-aware measurements without clipping glyph overhangs.
+- Make generated GUI scenarios favour ordinary values, respect literal numeric limits and progress ranges, and keep current/limit pairs coherent.
+
 ## 2.8.7 - 2026-08-28
 
 - Isolate stale, foreign, oversized, malformed, and address-mismatched artifact manifests so one bad generated record cannot block unrelated probability, event, GUI, or other MCP evidence routes.

package/dist/hoi4_agent_tools/gui/assets.js

@@ -43,6 +43,7 @@ export function parseBmFont(text) {
     let size = 16;
     let lineHeight = 16;
     let base;
+    let channelRoles;
     const pages = new Map();
     const characters = new Map();
     const kerning = new Map();
@@ -66,6 +67,9 @@ export function parseBmFont(text) {
             const fields = parseFields(line);
             lineHeight = typeof fields.lineHeight === 'number' ? fields.lineHeight : lineHeight;
             base = typeof fields.base === 'number' ? fields.base : base;
+            const roles = [fields.redChnl, fields.greenChnl, fields.blueChnl, fields.alphaChnl];
+            if (roles.every((role) => typeof role === 'number'))
+                channelRoles = roles;
             recognised = true;
         }
         else if (line.startsWith('page ')) {
@@ -137,6 +141,7 @@ export function parseBmFont(text) {
             pages: [...pages.entries()].sort(([left], [right]) => left - right).map(([, page]) => page),
             characters,
             kerning,
+            ...(channelRoles === undefined ? {} : { channelRoles }),
         }
         : undefined;
 }
@@ -156,6 +161,7 @@ export class GuiAssetCatalog {
     constructor(graph, scannedFiles, budget = new RenderBudget(), language = 'l_english') {
         this.graph = graph;
         this.budget = budget;
+        const sourceLoadOrder = new Map(scannedFiles.map((file) => [file.displayPath, file.loadOrder]));
         for (const file of scannedFiles
             .filter((candidate) => candidate.shadowedBy === undefined)
             .sort((left, right) => compareCodeUnits(left.relativePath, right.relativePath))) {
@@ -167,25 +173,38 @@ export class GuiAssetCatalog {
             this.basenames.set(basename, candidates);
         }
         const normalizedLanguage = language.toLocaleLowerCase('en-US');
-        for (const definition of graph.fonts) {
+        const eligibleFonts = graph.fonts.filter((definition) => definition.languages.length === 0 ||
+            definition.languages.some((candidate) => candidate.toLocaleLowerCase('en-US') === normalizedLanguage));
+        const definitionPriority = (definition) => {
+            const languageMatch = definition.languages.some((candidate) => candidate.toLocaleLowerCase('en-US') === normalizedLanguage);
+            return [
+                languageMatch ? 1 : 0,
+                sourceLoadOrder.get(definition.sourcePath) ?? 0,
+                languageMatch === definition.override ? 1 : 0,
+            ];
+        };
+        const higherPriority = (left, right) => {
+            const leftPriority = definitionPriority(left);
+            const rightPriority = definitionPriority(right);
+            for (let index = 0; index < leftPriority.length; index += 1) {
+                if (leftPriority[index] !== rightPriority[index])
+                    return leftPriority[index] > rightPriority[index];
+            }
+            return false;
+        };
+        for (const definition of eligibleFonts) {
             const key = definition.name.toLocaleLowerCase('en-US');
             const existing = this.fontDefinitions.get(key);
-            const definitionMatches = definition.languages.some((candidate) => candidate.toLocaleLowerCase('en-US') === normalizedLanguage);
-            const existingMatches = existing?.languages.some((candidate) => candidate.toLocaleLowerCase('en-US') === normalizedLanguage) ?? false;
-            if (existing === undefined ||
-                (definitionMatches && !existingMatches) ||
-                (definitionMatches === existingMatches && existing.override && !definition.override) ||
-                (definitionMatches === existingMatches &&
-                    existing.languages.length > 0 &&
-                    definition.languages.length === 0))
+            if (existing === undefined || higherPriority(definition, existing))
                 this.fontDefinitions.set(key, definition);
         }
         const baseDefinitions = new Map();
-        for (const definition of graph.fonts) {
+        for (const definition of eligibleFonts) {
             if (definition.override || definition.languages.length > 0)
                 continue;
             const key = definition.name.toLocaleLowerCase('en-US');
-            if (!baseDefinitions.has(key))
+            const existing = baseDefinitions.get(key);
+            if (existing === undefined || higherPriority(definition, existing))
                 baseDefinitions.set(key, definition);
         }
         for (const [key, definition] of this.fontDefinitions) {
@@ -211,7 +230,14 @@ export class GuiAssetCatalog {
         const extension = path.posix.extname(normalized);
         const rasterExtensions = ['.png', '.bmp', '.tga', '.dds', '.svg'];
         const normalizedCandidates = extension.length === 0
-            ? [normalized, `${normalized}.fnt`, `${normalized}.ttf`, `${normalized}.otf`]
+            ? [
+                normalized,
+                `${normalized}.fnt`,
+                `${normalized}.ttf`,
+                `${normalized}.otf`,
+                `${normalized}.woff`,
+                `${normalized}.woff2`,
+            ]
             : rasterExtensions.includes(extension)
                 ? [
                     normalized,
@@ -455,6 +481,7 @@ export class GuiAssetCatalog {
                         kind: 'bitmap',
                         key: `${entry.sourceFile.sha256}:${codePoint}:${Math.max(1, fontSize)}`,
                         dataUri: raster.dataUri,
+                        ...(raster.borderDataUri === undefined ? {} : { borderDataUri: raster.borderDataUri }),
                         x: penX + metric.xOffset * scale,
                         y: metric.yOffset * scale,
                         width: raster.width * scale,
@@ -591,14 +618,63 @@ export class GuiAssetCatalog {
                     .ensureAlpha()
                     .raw()
                     .toBuffer({ resolveWithObject: true });
-                const png = await sharp(extracted.data, {
+                const channelRoles = entry.bmfont?.channelRoles;
+                let facePixels = extracted.data;
+                let borderPixels;
+                if (channelRoles?.some((role) => role === 0) === true) {
+                    facePixels = Buffer.alloc(extracted.data.length);
+                    borderPixels = channelRoles.some((role) => role === 1)
+                        ? Buffer.alloc(extracted.data.length)
+                        : undefined;
+                    let backgroundSamples = 0;
+                    let backgroundTotal = 0;
+                    for (let offset = 0; offset < extracted.data.length; offset += 4) {
+                        const borderCoverage = channelRoles.reduce((maximum, role, channel) => role === 1 ? Math.max(maximum, extracted.data[offset + channel] ?? 0) : maximum, 0);
+                        if (borderCoverage !== 0)
+                            continue;
+                        for (let channel = 0; channel < 4; channel += 1) {
+                            if (channelRoles[channel] !== 0)
+                                continue;
+                            backgroundTotal += extracted.data[offset + channel] ?? 0;
+                            backgroundSamples += 1;
+                        }
+                    }
+                    const invertedFace = backgroundSamples > 0 && backgroundTotal / backgroundSamples > 127;
+                    for (let offset = 0; offset < extracted.data.length; offset += 4) {
+                        let faceCoverage = 0;
+                        let borderCoverage = 0;
+                        for (let channel = 0; channel < 4; channel += 1) {
+                            const sample = extracted.data[offset + channel] ?? 0;
+                            if (channelRoles[channel] === 0)
+                                faceCoverage = Math.max(faceCoverage, invertedFace ? 255 - sample : sample);
+                            if (channelRoles[channel] === 1)
+                                borderCoverage = Math.max(borderCoverage, sample);
+                        }
+                        facePixels[offset] = 255;
+                        facePixels[offset + 1] = 255;
+                        facePixels[offset + 2] = 255;
+                        facePixels[offset + 3] = faceCoverage;
+                        if (borderPixels !== undefined) {
+                            borderPixels[offset] = 255;
+                            borderPixels[offset + 1] = 255;
+                            borderPixels[offset + 2] = 255;
+                            borderPixels[offset + 3] = borderCoverage;
+                        }
+                    }
+                }
+                const encodeMask = (pixels) => sharp(pixels, {
                     raw: { width: extracted.info.width, height: extracted.info.height, channels: 4 },
                     limitInputPixels: RENDER_MAX_DECODED_PIXELS,
                 })
                     .png({ compressionLevel: 9, adaptiveFiltering: false, palette: false })
                     .toBuffer();
+                const png = await encodeMask(facePixels);
+                const borderPng = borderPixels === undefined ? undefined : await encodeMask(borderPixels);
                 return {
                     dataUri: `data:image/png;base64,${png.toString('base64')}`,
+                    ...(borderPng === undefined
+                        ? {}
+                        : { borderDataUri: `data:image/png;base64,${borderPng.toString('base64')}` }),
                     width: metric.width,
                     height: metric.height,
                 };

package/dist/hoi4_agent_tools/gui/layout.js

@@ -460,11 +460,9 @@ function colourRunsForLine(catalog, fontName, line, colours, fontSize, work, inl
         return [];
     const runs = [];
     let start = 0;
-    let offsetX = 0;
     while (start < line.length) {
         const inlineIcon = inlineIcons.get(line[start] ?? '');
         if (inlineIcon !== undefined) {
-            offsetX += inlineIcon.width;
             start += 1;
             continue;
         }
@@ -475,10 +473,12 @@ function colourRunsForLine(catalog, fontName, line, colours, fontSize, work, inl
             (colours[end] ?? defaultColour) === colour)
             end += 1;
         const text = line.slice(start, end);
-        work.spendTextLayout('localisation colour-run measurement');
-        const width = measureTextWithInlineIcons(catalog, fontName, text, fontSize, inlineIcons).width;
+        work.spendTextLayout('localisation colour-run prefix measurement');
+        const offsetX = measureTextWithInlineIcons(catalog, fontName, line.slice(0, start), fontSize, inlineIcons).width;
+        work.spendTextLayout('localisation colour-run end measurement');
+        const endX = measureTextWithInlineIcons(catalog, fontName, line.slice(0, end), fontSize, inlineIcons).width;
+        const width = Math.max(0, endX - offsetX);
         runs.push({ text, colour, offsetX, width });
-        offsetX += width;
         start = end;
     }
     return runs;

package/dist/hoi4_agent_tools/gui/renderer.js

@@ -33,8 +33,8 @@ function colourFor(value) {
 function outlineDefinitionId(key) {
     return `gui-font-outline-${sha256Bytes(key).slice(0, 20)}`;
 }
-function bitmapDefinitionId(key) {
-    return `gui-font-bitmap-${sha256Bytes(key).slice(0, 20)}`;
+function bitmapDefinitionId(key, layer = 'face') {
+    return `gui-font-bitmap-${layer === 'face' ? '' : 'border-'}${sha256Bytes(key).slice(0, 20)}`;
 }
 function sceneGlyphDefinitions(scene) {
     const outlines = new Map();
@@ -47,6 +47,7 @@ function sceneGlyphDefinitions(scene) {
                 else
                     bitmaps.set(glyph.key, {
                         dataUri: glyph.dataUri,
+                        ...(glyph.borderDataUri === undefined ? {} : { borderDataUri: glyph.borderDataUri }),
                         width: glyph.width,
                         height: glyph.height,
                     });
@@ -59,7 +60,7 @@ function sceneGlyphDefinitions(scene) {
             .map(([key, glyphPath]) => `<path id="${outlineDefinitionId(key)}" d="${glyphPath}"/>`),
         ...[...bitmaps.entries()]
             .sort(([left], [right]) => compareCodeUnits(left, right))
-            .map(([key, glyph]) => `<image id="${bitmapDefinitionId(key)}" width="${finite(glyph.width)}" height="${finite(glyph.height)}" href="${glyph.dataUri}" preserveAspectRatio="none"/>`),
+            .map(([key, glyph]) => `<image id="${bitmapDefinitionId(key)}" width="${finite(glyph.width)}" height="${finite(glyph.height)}" href="${glyph.dataUri}" preserveAspectRatio="none"/>${glyph.borderDataUri === undefined ? '' : `<image id="${bitmapDefinitionId(key, 'border')}" width="${finite(glyph.width)}" height="${finite(glyph.height)}" href="${glyph.borderDataUri}" preserveAspectRatio="none"/>`}`),
     ].join('');
 }
 function bitmapTintMarkup(id, colour, glyphs, rect) {
@@ -76,7 +77,7 @@ function bitmapTintMarkup(id, colour, glyphs, rect) {
     const matrix = `${red} 0 0 0 0 0 ${green} 0 0 0 0 0 ${blue} 0 0 0 0 0 ${opacity} 0`;
     return `<defs><filter id="${id}" filterUnits="userSpaceOnUse" ${rectAttributes(rect)} color-interpolation-filters="sRGB"><feColorMatrix type="matrix" values="${matrix}"/></filter></defs><g filter="url(#${id})">${glyphs}</g>`;
 }
-function actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale) {
+function actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale, bitmapLayer = 'face') {
     if (glyphLine.source === 'fontkit-path')
         return glyphLine.glyphs
             .filter((glyph) => glyph.kind === 'outline')
@@ -85,7 +86,8 @@ function actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale) {
     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)"/>`)
+            .filter((glyph) => bitmapLayer === 'face' || glyph.borderDataUri !== undefined)
+            .map((glyph) => `<use href="#${bitmapDefinitionId(glyph.key, bitmapLayer)}" transform="translate(${finite(originX + glyph.x * horizontalScale)} ${finite(baseline + glyph.y - glyphLine.baseline)}) scale(${finite(horizontalScale)} 1)"/>`)
             .join('');
     return '';
 }
@@ -137,17 +139,22 @@ function renderText(element, toolText) {
                 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>`);
+                definitions.push(`<clipPath id="${clipId}"><rect x="${finite(runX - 0.25)}" y="${finite(lineTop - text.lineHeight)}" width="${finite(run.width * horizontalScale + 0.5)}" height="${finite(text.lineHeight * 3)}"/></clipPath>`);
                 const glyphs = actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale);
                 if (glyphLine.source === 'bmfont-atlas') {
-                    const maskId = `gui-font-mask-${sha256Bytes(key).slice(0, 20)}`;
+                    const faceFilterId = `gui-font-face-${sha256Bytes(key).slice(0, 20)}`;
+                    const borderFilterId = `gui-font-border-${sha256Bytes(key).slice(0, 20)}`;
                     const runRect = {
                         x: runX - 0.25,
-                        y: lineTop,
+                        y: lineTop - text.lineHeight,
                         width: run.width * horizontalScale + 0.5,
-                        height: text.lineHeight,
+                        height: text.lineHeight * 3,
                     };
-                    return `<g clip-path="url(#${clipId})" data-font-colour="${run.colour}">${bitmapTintMarkup(maskId, run.colour, glyphs, runRect)}</g>`;
+                    const borderGlyphs = actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale, 'border');
+                    const border = borderGlyphs.length === 0
+                        ? ''
+                        : bitmapTintMarkup(borderFilterId, text.borderColour ?? '#000000ff', borderGlyphs, runRect);
+                    return `<g clip-path="url(#${clipId})" data-font-colour="${run.colour}">${border}${bitmapTintMarkup(faceFilterId, run.colour, glyphs, runRect)}</g>`;
                 }
                 return `<g clip-path="url(#${clipId})" fill="${run.colour}" stroke="${text.borderColour ?? '#12151a'}" data-font-colour="${run.colour}">${glyphs}</g>`;
             });
@@ -171,11 +178,17 @@ function renderText(element, toolText) {
         }
         if (glyphLine?.source === 'bmfont-atlas') {
             const glyphs = actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale);
-            if (text.colour === undefined)
+            const borderGlyphs = actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale, 'border');
+            if (text.colour === undefined && borderGlyphs.length === 0)
                 return `<g data-font-sha256="${glyphLine.sourceHash}">${glyphs}${inlineIconMarkup}</g>`;
-            const maskId = `gui-font-mask-${sha256Bytes(`${element.id}:${index}:${text.colour}`).slice(0, 20)}`;
+            const colour = text.colour ?? '#ffffffff';
+            const faceFilterId = `gui-font-face-${sha256Bytes(`${element.id}:${index}:${colour}`).slice(0, 20)}`;
+            const borderFilterId = `gui-font-border-${sha256Bytes(`${element.id}:${index}:${text.borderColour ?? '#000000ff'}`).slice(0, 20)}`;
             const lineRect = { x: originX, y: lineTop, width, height: text.lineHeight };
-            return `<g data-font-sha256="${glyphLine.sourceHash}" data-font-colour="${text.colour}">${bitmapTintMarkup(maskId, text.colour, glyphs, lineRect)}${inlineIconMarkup}</g>`;
+            const border = borderGlyphs.length === 0
+                ? ''
+                : bitmapTintMarkup(borderFilterId, text.borderColour ?? '#000000ff', borderGlyphs, lineRect);
+            return `<g data-font-sha256="${glyphLine.sourceHash}" data-font-colour="${colour}">${border}${bitmapTintMarkup(faceFilterId, colour, glyphs, lineRect)}${inlineIconMarkup}</g>`;
         }
         const visibleLine = line.replace(/[\uE000-\uF8FF]/gu, ' ');
         return `<g>${toolText.render(visibleLine, {

package/dist/hoi4_agent_tools/gui/scenario-generator.js

@@ -52,6 +52,9 @@ class ScenarioRandom {
     integer(minimum, maximum) {
         return Math.floor(this.next() * (maximum - minimum + 1)) + minimum;
     }
+    ordinary() {
+        return (this.next() + this.next() + this.next()) / 3;
+    }
     pick(values) {
         return values[Math.min(values.length - 1, Math.floor(this.next() * values.length))];
     }
@@ -182,18 +185,64 @@ function plausibleText(key, random, samples, scopedCountries) {
 function generatedNumber(options, random, minimum = options.numericMinimum, maximum = options.numericMaximum) {
     const boundedMinimum = Math.max(options.numericMinimum, minimum);
     const boundedMaximum = Math.min(options.numericMaximum, maximum);
-    const low = Math.min(boundedMinimum, boundedMaximum);
-    const high = Math.max(boundedMinimum, boundedMaximum);
-    const value = low + random.next() * (high - low);
+    const [low, high] = boundedMinimum <= boundedMaximum
+        ? [boundedMinimum, boundedMaximum]
+        : maximum < options.numericMinimum
+            ? [maximum, maximum]
+            : [minimum, minimum];
+    const value = low + random.ordinary() * (high - low);
     return options.integerValues ? Math.round(value) : Math.round(value * 100) / 100;
 }
-function generatedNumberForKey(key, options, random) {
+function sourceNumericConstraints(texts) {
+    const ranges = new Map();
+    const relationships = [];
+    const update = (key, range) => {
+        const current = ranges.get(key) ?? {};
+        const minimum = range.minimum === undefined
+            ? current.minimum
+            : current.minimum === undefined
+                ? range.minimum
+                : Math.max(current.minimum, range.minimum);
+        const maximum = range.maximum === undefined
+            ? current.maximum
+            : current.maximum === undefined
+                ? range.maximum
+                : Math.min(current.maximum, range.maximum);
+        ranges.set(key, {
+            ...(minimum === undefined ? {} : { minimum }),
+            ...(maximum === undefined ? {} : { maximum }),
+        });
+    };
+    const token = String.raw `\[\?([^\]|]+)(?:\|[^\]]+)?\]`;
+    for (const text of texts) {
+        for (const match of text.matchAll(new RegExp(`${token}\\s*(?:/|of)\\s*(-?(?:\\d+\\.?\\d*|\\.\\d+))`, 'giu'))) {
+            const key = match[1];
+            const maximum = Number(match[2]);
+            if (key !== undefined && Number.isFinite(maximum))
+                update(key, { maximum });
+        }
+        for (const match of text.matchAll(new RegExp(`(-?(?:\\d+\\.?\\d*|\\.\\d+))\\s*(?:-|to)\\s*${token}`, 'giu'))) {
+            const minimum = Number(match[1]);
+            const key = match[2];
+            if (key !== undefined && Number.isFinite(minimum))
+                update(key, { minimum });
+        }
+        for (const match of text.matchAll(new RegExp(`${token}\\s*(?:/|of)\\s*${token}`, 'giu'))) {
+            const value = match[1];
+            const limit = match[2];
+            if (value !== undefined && limit !== undefined)
+                relationships.push({ value, limit });
+        }
+    }
+    return { ranges, relationships };
+}
+function generatedNumberForKey(key, options, random, inferred = {}) {
     const lower = key.toLocaleLowerCase('en-US');
     if (/(?:ratio|fraction|progress)$/u.test(lower))
-        return generatedNumber(options, random, 0, 1);
+        return generatedNumber(options, random, inferred.minimum ?? 0, inferred.maximum ?? 1);
     if (/(?:percent|percentage|support|stability|war_support|legitimacy|threat|charge)/u.test(lower))
-        return generatedNumber(options, random, 0, 100);
-    return generatedNumber(options, random);
+        return generatedNumber(options, random, inferred.minimum ?? 0, inferred.maximum ?? 100);
+    return generatedNumber(options, random, inferred.minimum ?? options.numericMinimum, inferred.maximum ?? options.numericMaximum);
 }
 function setIfMissing(target, key, value) {
     target[key] ??= value;
@@ -419,7 +468,9 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         return [];
     const scripted = relatedScriptedGuis(graph, windowName);
     const elements = relevantElements(graph, windowName, scripted);
-    const tokens = tokensIn(sourceTexts(graph, elements, base.language, scripted));
+    const relevantSourceTexts = sourceTexts(graph, elements, base.language, scripted);
+    const tokens = tokensIn(relevantSourceTexts);
+    const numericConstraints = sourceNumericConstraints(relevantSourceTexts);
     const imageTokens = new Set();
     const booleanTokens = new Set();
     const frameTokens = new Set();
@@ -482,7 +533,7 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         const elementStates = { ...base.elementStates };
         const scopedCountries = new Map();
         for (const key of tokens.numeric)
-            setIfMissing(values, key, generatedNumberForKey(key, options, random));
+            setIfMissing(values, key, generatedNumberForKey(key, options, random, numericConstraints.ranges.get(key)));
         for (const [elementName, { minimum, maximum }] of progressRanges) {
             const element = elements.find(({ name }) => name === elementName);
             const startValueToken = typeof element?.attributes.startValue === 'string'
@@ -507,6 +558,16 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
             if (typeof sourceValue === 'number')
                 values[key] = sourceValue;
         }
+        for (const { value: valueKey, limit: limitKey } of numericConstraints.relationships) {
+            if (base.values[valueKey] !== undefined)
+                continue;
+            const value = values[valueKey];
+            const limit = values[limitKey];
+            if (typeof value !== 'number' || typeof limit !== 'number')
+                continue;
+            const minimum = Math.min(numericConstraints.ranges.get(valueKey)?.minimum ?? options.numericMinimum, limit);
+            values[valueKey] = Math.max(minimum, Math.min(value, limit));
+        }
         for (const key of tokens.textual)
             setIfMissing(values, key, plausibleText(key, random, options.textSamples, scopedCountries));
         const scriptedTextTemplates = new Map();

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

@@ -208,15 +208,44 @@ function boolScalar(block, ...keys) {
         return false;
     return undefined;
 }
+function colourChannels(value) {
+    if (value === undefined)
+        return undefined;
+    const channels = value.entries
+        .filter((entry) => entry.type === 'scalar')
+        .map((entry) => Number(entry.value));
+    if (channels.length < 3 || channels.slice(0, 4).some((channel) => !Number.isFinite(channel)))
+        return undefined;
+    const normalized = channels.slice(0, 4).every((channel) => channel >= 0 && channel <= 1);
+    const bytes = channels
+        .slice(0, 4)
+        .map((channel) => Math.max(0, Math.min(255, Math.round(channel * (normalized ? 255 : 1)))));
+    while (bytes.length < 4)
+        bytes.push(255);
+    return `#${bytes.map((channel) => channel.toString(16).padStart(2, '0')).join('')}`;
+}
 function paradoxColour(value) {
     if (value === undefined)
         return undefined;
-    const match = /^0x([0-9a-f]{8})$/iu.exec(value.trim());
+    const match = /^0x([0-9a-f]{6}|[0-9a-f]{8})$/iu.exec(value.trim());
     if (match === null)
         return undefined;
+    if (match[1].length === 6)
+        return `#${match[1].toLowerCase()}ff`;
     const argb = match[1];
     return `#${argb.slice(2)}${argb.slice(0, 2)}`.toLowerCase();
 }
+function colourFrom(block, ...keys) {
+    const normalized = new Set(keys.map((key) => key.toLowerCase()));
+    for (const assignment of assignments(block)) {
+        if (!normalized.has(assignment.key.value.toLowerCase()))
+            continue;
+        if (assignment.value.type === 'scalar')
+            return paradoxColour(assignment.value.value);
+        return colourChannels(assignment.value);
+    }
+    return undefined;
+}
 function textColoursFrom(block) {
     const textColours = childBlocks(block, 'textcolors')[0];
     if (textColours === undefined)
@@ -225,15 +254,9 @@ function textColoursFrom(block) {
     for (const entry of assignments(textColours)) {
         if (entry.value.type !== 'block')
             continue;
-        const channels = entry.value.entries
-            .filter((channel) => channel.type === 'scalar')
-            .map((channel) => Number(channel.value));
-        if (channels.length < 3 || channels.slice(0, 3).some((channel) => !Number.isFinite(channel)))
-            continue;
-        const [red, green, blue] = channels.map((channel) => Math.max(0, Math.min(255, Math.round(channel))));
-        result[entry.key.value] = `#${red.toString(16).padStart(2, '0')}${green
-            .toString(16)
-            .padStart(2, '0')}${blue.toString(16).padStart(2, '0')}`;
+        const colour = colourChannels(entry.value);
+        if (colour !== undefined)
+            result[entry.key.value] = colour.slice(0, 7);
     }
     return result;
 }
@@ -462,8 +485,8 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                     addEdge(edges, 'contains', fileNodeId, id, true, {}, definition.location);
                 }
             }
-            else if (assignment.key.value === 'bitmapfont' ||
-                assignment.key.value === 'bitmapfont_override') {
+            else if (assignment.key.value.toLowerCase() === 'bitmapfont' ||
+                assignment.key.value.toLowerCase() === 'bitmapfont_override') {
                 const name = firstScalarInsensitive(child, 'name');
                 if (name !== undefined) {
                     const assetPaths = [firstScalarInsensitive(child, 'path')]
@@ -474,10 +497,10 @@ 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 colour = colourFrom(child, 'color', 'colour');
+                    const borderColour = colourFrom(child, 'border_color', 'borderColor', 'border_colour');
                     const textColours = textColoursFrom(child);
-                    const override = assignment.key.value === 'bitmapfont_override';
+                    const override = assignment.key.value.toLowerCase() === 'bitmapfont_override';
                     const id = deterministicId('gui_font', {
                         path: file.displayPath,
                         name,
@@ -519,7 +542,7 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                     addEdge(edges, 'contains', fileNodeId, id, true, {}, font.location);
                 }
             }
-            if (assignment.key.value === 'bitmapfonts') {
+            if (assignment.key.value.toLowerCase() === 'bitmapfonts') {
                 Object.assign(globalTextColours, textColoursFrom(child));
             }
             walk(child);

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

package/docs/gui.md

@@ -33,7 +33,7 @@ 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` 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.
+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. The renderer reads BMFont channel roles, separates face and outline coverage, and recognizes both vanilla black-on-white masks and conventional white-on-transparent custom masks. HOI4 localisation colour runs such as `§Y` and `§R` therefore colour the glyph face while retaining its sharp antialiasing and declared border 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.
 
@@ -41,7 +41,7 @@ Scripted-GUI composition follows `parent_scripted_gui` chains even when the link
 
 `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. 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.
+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. Generated numeric values favour ordinary mid-range states, obey literal limits such as `[?capacity]/10`, keep displayed current/limit pairs coherent, and remain inside progress-bar ranges. 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
 {
@@ -95,4 +95,4 @@ The renderer does not run the game engine. Each render includes a fidelity repor
 
 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.
+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. Font selection follows mod/game load order and preview language, accepts Paradox hex and numeric color declarations, and uses the supplied HOI4 bitmap or outline font assets without requiring host font installation. 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.7",
+  "version": "2.8.9",
   "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.7/schemas/configuration.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/continuous-focus-palette.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/custom-weighted-pool.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/event-feature-manifest.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/focus-plan.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/focus-planning-sidecar.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/gui-animation-source.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/gui-helper.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/gui-scenario.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/map-operation.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/operation-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/probability-analysis-result.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/probability-compare-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/probability-evaluate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/probability-inspect-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/probability-render-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/probability-scenario-set.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/probability-sequence-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/probability-simulate-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7/schemas/probability-sweep-input.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v2.8.9/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.7",
+  "version": "2.8.9",
   "repository": {
     "url": "https://github.com/klimPaskov/hoi4-agent-tools",
     "source": "github"
@@ -13,7 +13,7 @@
     {
       "registryType": "npm",
       "identifier": "hoi4-agent-tools",
-      "version": "2.8.7",
+      "version": "2.8.9",
       "transport": {
         "type": "stdio"
       }