hoi4-agent-tools 2.8.5 → 2.8.6

package/CHANGELOG.md

@@ -4,6 +4,12 @@
 
 No unreleased changes.
 
+## 2.8.6 - 2026-08-28
+
+- Generate source-aware scripted-GUI scenarios from complete parent/child surfaces, real scripted-localisation candidates, simple threshold conditions, coherent tab states, scoped values, meter ranges, and dynamic-list rows while keeping explicit scenario values authoritative.
+- Preserve native HOI4 bitmap-font antialiasing and shadow pixels when applying face and localisation colours, including global and per-font `textcolors` palettes.
+- Prevent stale workspace artifacts and irrelevant language font atlases from blocking GUI calls, resolve alternate vanilla raster extensions and repeated path separators, and keep placeholder scenarios opt-in so their intentionally unresolved state does not pollute normal validation.
+
 ## 2.8.5 - 2026-08-28
 
 - Render bitmap-font face and localisation colours through alpha masks, including black source atlases, and load exact per-font HOI4 `textcolors` palettes.

package/dist/hoi4_agent_tools/core/artifacts.js

@@ -131,9 +131,14 @@ export function boundedSourceHashEvidence(sourceHashes) {
     };
 }
 function assertManifestIntegrity(manifest, expected, workspace) {
+    assertManifestAddressIntegrity(manifest, expected);
     if (manifest.workspaceIdentity !== workspace.workspaceIdentity ||
-        manifest.ownerIdentity !== workspace.ownerIdentity ||
-        manifest.sha256 !== expected.sha256 ||
+        manifest.ownerIdentity !== workspace.ownerIdentity) {
+        throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest does not match its immutable address');
+    }
+}
+function assertManifestAddressIntegrity(manifest, expected) {
+    if (manifest.sha256 !== expected.sha256 ||
         manifest.provenanceHash !== expected.provenanceHash ||
         manifest.name !== expected.name ||
         provenanceHashFor(manifest) !== expected.provenanceHash) {
@@ -712,11 +717,11 @@ export class ArtifactStore {
                 if (child.name !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`) {
                     throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest filename does not match its contents');
                 }
-                assertManifestIntegrity(manifest, {
+                assertManifestAddressIntegrity(manifest, {
                     sha256: path.basename(directory),
                     provenanceHash: manifest.provenanceHash,
                     name: manifest.name,
-                }, workspace);
+                });
                 const targetPath = await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, path.join(directory, manifest.name)));
                 let targetBytes = 0;
                 try {
@@ -728,6 +733,8 @@ export class ArtifactStore {
                 }
                 retained.push({
                     manifest,
+                    staleIdentity: manifest.workspaceIdentity !== workspace.workspaceIdentity ||
+                        manifest.ownerIdentity !== workspace.ownerIdentity,
                     manifestPath: candidate,
                     manifestBytes: metadata.size,
                     modifiedAt: metadata.mtimeMs,
@@ -789,7 +796,8 @@ export class ArtifactStore {
             }
         };
         await reclaimDebris(await containedGeneratedPath(workspace.artifactRoot));
-        retained.sort((left, right) => left.modifiedAt - right.modifiedAt ||
+        retained.sort((left, right) => Number(right.staleIdentity) - Number(left.staleIdentity) ||
+            left.modifiedAt - right.modifiedAt ||
             compareCodeUnits(left.manifestPath, right.manifestPath));
         const current = { ...usage };
         for (const candidate of retained) {
@@ -822,7 +830,7 @@ export class ArtifactStore {
                 if (error.code !== 'ENOENT')
                     throw error;
             }
-            const verificationPrefix = `${workspace.workspaceIdentity}\0${workspace.ownerIdentity}\0${candidate.targetPath}\0`;
+            const verificationPrefix = `${candidate.manifest.workspaceIdentity}\0${candidate.manifest.ownerIdentity}\0${candidate.targetPath}\0`;
             for (const key of this.#verifiedContent.keys()) {
                 if (key.startsWith(verificationPrefix))
                     this.#verifiedContent.delete(key);

package/dist/hoi4_agent_tools/gui/assets.js

@@ -591,11 +591,6 @@ export class GuiAssetCatalog {
                     .ensureAlpha()
                     .raw()
                     .toBuffer({ resolveWithObject: true });
-                for (let index = 0; index < extracted.data.length; index += 4) {
-                    extracted.data[index] = 255;
-                    extracted.data[index + 1] = 255;
-                    extracted.data[index + 2] = 255;
-                }
                 const png = await sharp(extracted.data, {
                     raw: { width: extracted.info.width, height: extracted.info.height, channels: 4 },
                     limitInputPixels: RENDER_MAX_DECODED_PIXELS,

package/dist/hoi4_agent_tools/gui/layout.js

@@ -750,7 +750,10 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             displayText = `\u00a7R${rawText}_MISSING\u00a7!`;
         const fontName = scalarString(property(definition.attributes, 'font', 'buttonFont'));
         const fontDefinition = fontName === undefined ? undefined : catalog.fontDefinition(fontName);
-        const visibleText = visibleHoiText(displayText, fontDefinition?.textColours);
+        const visibleText = visibleHoiText(displayText, {
+            ...context.graph.textColours,
+            ...fontDefinition?.textColours,
+        });
         displayText = visibleText.text;
         context.work.admitText(displayText, `GUI text for ${definition.name}`);
         const resolvedFontMetrics = catalog.resolvedFontMetrics(fontName);

package/dist/hoi4_agent_tools/gui/renderer.js

@@ -63,7 +63,18 @@ function sceneGlyphDefinitions(scene) {
     ].join('');
 }
 function bitmapTintMarkup(id, colour, glyphs, rect) {
-    return `<defs><mask id="${id}" maskUnits="userSpaceOnUse" maskContentUnits="userSpaceOnUse" style="mask-type:alpha" ${rectAttributes(rect)}><g>${glyphs}</g></mask></defs><rect ${rectAttributes(rect)} fill="${colour}" mask="url(#${id})"/>`;
+    const match = /^#([0-9a-f]{6})([0-9a-f]{2})?$/iu.exec(colour);
+    const rgb = match?.[1] ?? 'ffffff';
+    const alpha = match?.[2] ?? 'ff';
+    const channels = [
+        Number.parseInt(rgb.slice(0, 2), 16) / 255,
+        Number.parseInt(rgb.slice(2, 4), 16) / 255,
+        Number.parseInt(rgb.slice(4, 6), 16) / 255,
+        Number.parseInt(alpha, 16) / 255,
+    ].map(finite);
+    const [red, green, blue, opacity] = channels;
+    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) {
     if (glyphLine.source === 'fontkit-path')

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

@@ -11,6 +11,20 @@ const countryAdjectives = [
     'Canadian',
 ];
 const leaderNames = ['Anna Keller', 'Michael Byrne', 'Elena Rossi', 'Jan Kowalski', 'Rafael Silva'];
+const monthNames = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+];
 const variedStates = [
     'normal',
     'selected',
@@ -19,6 +33,7 @@ const variedStates = [
     'disabled',
     'completed',
 ];
+const transientWindowPattern = /(?:confirm|details|dialog|dropdown|menu|modal|overlay|popup|tooltip)/iu;
 class ScenarioRandom {
     #state;
     constructor(seed) {
@@ -41,26 +56,50 @@ class ScenarioRandom {
         return values[Math.min(values.length - 1, Math.floor(this.next() * values.length))];
     }
 }
-function relevantElements(graph, windowName) {
-    const root = graph.elements.find((element) => element.parentId === undefined && element.name === windowName);
-    if (root === undefined)
-        return graph.elements.filter(({ name }) => name === windowName);
+function relatedScriptedGuis(graph, windowName) {
+    const names = new Set(graph.scriptedGuis
+        .filter((definition) => definition.windowName === windowName || definition.parentWindowName === windowName)
+        .map(({ name }) => name));
+    let added = true;
+    while (added) {
+        added = false;
+        for (const definition of graph.scriptedGuis) {
+            if (definition.parentScriptedGui === undefined ||
+                !names.has(definition.parentScriptedGui) ||
+                names.has(definition.name))
+                continue;
+            names.add(definition.name);
+            added = true;
+        }
+    }
+    return graph.scriptedGuis.filter(({ name }) => names.has(name));
+}
+function relevantElements(graph, windowName, scripted) {
+    const rootNames = new Set([windowName]);
+    for (const definition of scripted) {
+        if (definition.windowName !== undefined)
+            rootNames.add(definition.windowName);
+        for (const dynamicList of definition.dynamicListDefinitions) {
+            if (dynamicList.entryContainer !== undefined)
+                rootNames.add(dynamicList.entryContainer);
+            if (dynamicList.countryScopeEntryContainer !== undefined)
+                rootNames.add(dynamicList.countryScopeEntryContainer);
+        }
+    }
     const byId = new Map(graph.elements.map((element) => [element.id, element]));
-    const pending = [root.id];
-    const selected = [];
-    const seen = new Set();
+    const pending = graph.elements.filter(({ name }) => rootNames.has(name)).map(({ id }) => id);
+    const selected = new Map();
     while (pending.length > 0) {
         const id = pending.pop();
-        if (seen.has(id))
+        if (id === undefined || selected.has(id))
             continue;
-        seen.add(id);
         const element = byId.get(id);
         if (element === undefined)
             continue;
-        selected.push(element);
+        selected.set(id, element);
         pending.push(...element.childIds);
     }
-    return selected;
+    return [...selected.values()];
 }
 function stringsIn(value) {
     if (typeof value === 'string')
@@ -70,18 +109,37 @@ function stringsIn(value) {
     return Object.values(value).flatMap(stringsIn);
 }
 function localisationText(graph, language, key) {
-    return graph.localisation.find((entry) => entry.language === language && entry.key === key)
-        ?.value;
+    const normalizedLanguage = language.toLocaleLowerCase('en-US');
+    return graph.localisation.find((entry) => entry.key === key && entry.language.toLocaleLowerCase('en-US') === normalizedLanguage)?.value;
 }
 function sourceTexts(graph, elements, language, scripted) {
     const values = elements.flatMap((element) => Object.values(element.attributes).flatMap(stringsIn));
-    const propertyValues = scripted.flatMap((definition) => definition.propertyDefinitions.flatMap((property) => Object.values(property.attributes).flatMap(stringsIn)));
-    return [...values, ...propertyValues].flatMap((value) => [
+    const resolvedValues = values.flatMap((value) => [
         value,
         localisationText(graph, language, value) ?? '',
     ]);
+    const relatedScriptedLocalisationKeys = new Set(graph.scriptedLocalisation
+        .filter((definition) => resolvedValues.some((value) => value.includes(`[${definition.name}]`)))
+        .flatMap(({ localisationKeys }) => localisationKeys));
+    const propertyValues = scripted.flatMap(({ propertyDefinitions }) => propertyDefinitions.flatMap(({ attributes }) => Object.values(attributes).flatMap(stringsIn)));
+    const normalizedLanguage = language.toLocaleLowerCase('en-US');
+    return [
+        ...resolvedValues,
+        ...propertyValues,
+        ...graph.localisation
+            .filter(({ language: entryLanguage, key }) => entryLanguage.toLocaleLowerCase('en-US') === normalizedLanguage &&
+            relatedScriptedLocalisationKeys.has(key))
+            .map(({ value }) => value),
+    ];
+}
+function expressionToken(value) {
+    if (typeof value !== 'string')
+        return undefined;
+    const variable = /^\[\?([^\]|]+)(?:\|[^\]]+)?\]$/u.exec(value);
+    const dynamic = /^\[([^\]]+)\]$/u.exec(value);
+    return variable?.[1] ?? dynamic?.[1];
 }
-function dynamicTokens(texts) {
+function tokensIn(texts) {
     const numeric = new Set();
     const textual = new Set();
     for (const text of texts) {
@@ -98,33 +156,248 @@ function dynamicTokens(texts) {
                 textual.add(key);
         }
     }
-    return {
-        numeric: [...numeric].sort(),
-        textual: [...textual].sort(),
-    };
+    return { numeric, textual };
 }
-function plausibleText(key, random, samples) {
+function plausibleText(key, random, samples, scopedCountries) {
     const lower = key.toLocaleLowerCase('en-US');
+    if (lower.includes('date'))
+        return `${random.integer(1, 28)} ${random.pick(monthNames)} ${random.integer(1936, 1950)}`;
     if (lower.includes('adjective'))
         return random.pick(countryAdjectives);
     if (lower.includes('leader') || lower.includes('character'))
         return random.pick(leaderNames);
-    if (lower.includes('country') || lower.endsWith('getname') || lower.includes('.getname'))
-        return random.pick(countryNames);
+    if (lower.includes('country') || lower.endsWith('getname') || lower.includes('.getname')) {
+        const scope = key.includes('.') ? key.slice(0, key.indexOf('.')) : 'ROOT';
+        const existing = scopedCountries.get(scope);
+        if (existing !== undefined)
+            return existing;
+        const used = new Set(scopedCountries.values());
+        const choices = countryNames.filter((candidate) => !used.has(candidate));
+        const value = random.pick(choices.length === 0 ? countryNames : choices);
+        scopedCountries.set(scope, value);
+        return value;
+    }
     return random.pick(samples);
 }
-function generatedNumber(options, random) {
-    const value = options.numericMinimum + random.next() * (options.numericMaximum - options.numericMinimum);
+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);
     return options.integerValues ? Math.round(value) : Math.round(value * 100) / 100;
 }
+function generatedNumberForKey(key, options, random) {
+    const lower = key.toLocaleLowerCase('en-US');
+    if (/(?:ratio|fraction|progress)$/u.test(lower))
+        return generatedNumber(options, random, 0, 1);
+    if (/(?:percent|percentage|support|stability|war_support|legitimacy|threat|charge)/u.test(lower))
+        return generatedNumber(options, random, 0, 100);
+    return generatedNumber(options, random);
+}
 function setIfMissing(target, key, value) {
     target[key] ??= value;
-    const shortKey = key.slice(key.lastIndexOf('.') + 1);
-    target[shortKey] ??= value;
+}
+function scriptedLocalisationValue(graph, token, language, random, kind, values) {
+    const shortToken = token.slice(token.lastIndexOf('.') + 1);
+    const definitions = graph.scriptedLocalisation.filter(({ name }) => name === token || name === shortToken);
+    if (definitions.length === 0)
+        return undefined;
+    const sprites = new Set(graph.sprites.map(({ name }) => name.toLocaleLowerCase('en-US')));
+    const choices = definitions.flatMap(({ choices }) => choices);
+    const eligible = choices.filter(({ localisationKey }) => kind === 'image'
+        ? sprites.has(localisationKey.toLocaleLowerCase('en-US'))
+        : localisationText(graph, language, localisationKey) !== undefined);
+    if (eligible.length === 0)
+        return undefined;
+    const evaluated = eligible.map((choice) => ({
+        choice,
+        result: evaluateSimpleTrigger(choice.triggerExpression, values),
+    }));
+    const matched = evaluated.find(({ result }) => result === true)?.choice;
+    const firstThreshold = evaluated
+        .map(({ choice }) => simpleThreshold(choice.triggerExpression))
+        .find((threshold) => threshold !== undefined && typeof values[threshold.variable] === 'number');
+    const unknownExists = evaluated.some(({ result }) => result === undefined);
+    const ranked = matched === undefined && unknownExists && firstThreshold !== undefined
+        ? eligible[Math.min(eligible.length - 1, Math.max(0, Math.round((1 - Math.max(0, Math.min(100, Number(values[firstThreshold.variable]))) / 100) *
+            (eligible.length - 1))))]
+        : undefined;
+    const fallback = evaluated.find(({ result }) => result === 'fallback')?.choice;
+    const selected = matched ?? ranked ?? fallback ?? random.pick(eligible);
+    if (kind === 'image')
+        return selected.localisationKey;
+    return localisationText(graph, language, selected.localisationKey);
+}
+function simpleThreshold(triggerExpression) {
+    if (triggerExpression === undefined)
+        return undefined;
+    const direct = /([A-Za-z_][A-Za-z0-9_.:^]*)\s*([<>])\s*(-?(?:\d+\.?\d*|\.\d+))/u.exec(triggerExpression);
+    if (direct !== null)
+        return {
+            variable: direct[1],
+            operator: direct[2],
+            threshold: Number(direct[3]),
+        };
+    const variable = /\bvar\s*=\s*([A-Za-z_][A-Za-z0-9_.:^]*)/u.exec(triggerExpression)?.[1];
+    const threshold = /\bvalue\s*=\s*(-?(?:\d+\.?\d*|\.\d+))/u.exec(triggerExpression)?.[1];
+    const compare = /\bcompare\s*=\s*(greater_than|less_than)/u.exec(triggerExpression)?.[1];
+    if (variable === undefined || threshold === undefined || compare === undefined)
+        return undefined;
+    return {
+        variable,
+        operator: compare === 'greater_than' ? '>' : '<',
+        threshold: Number(threshold),
+    };
+}
+function evaluateSimpleTrigger(triggerExpression, values) {
+    if (triggerExpression === undefined || /\balways\s*=\s*yes\b/u.test(triggerExpression))
+        return 'fallback';
+    if (/\balways\s*=\s*no\b/u.test(triggerExpression))
+        return false;
+    const threshold = simpleThreshold(triggerExpression);
+    if (threshold === undefined)
+        return undefined;
+    const value = values[threshold.variable];
+    if (typeof value !== 'number')
+        return undefined;
+    return threshold.operator === '>' ? value > threshold.threshold : value < threshold.threshold;
+}
+function materializeDynamicText(template, values) {
+    const valueFor = (key) => {
+        const value = values[key] ?? values[key.slice(key.lastIndexOf('.') + 1)];
+        return value === undefined ? undefined : String(value);
+    };
+    return template
+        .replace(/\[\?([^\]|]+)(?:\|[^\]]+)?\]/gu, (match, key) => valueFor(key) ?? match)
+        .replace(/\[([A-Za-z][A-Za-z0-9_.:-]+)\]/gu, (match, key) => {
+        if (key === 'X' || key === 'dynamic_loc')
+            return match;
+        return valueFor(key) ?? match;
+    });
+}
+function scalarNumber(value) {
+    if (typeof value === 'number' && Number.isFinite(value))
+        return value;
+    if (typeof value !== 'string' || !/^-?(?:\d+\.?\d*|\.\d+)$/u.test(value))
+        return undefined;
+    return Number(value);
+}
+function pointOrSize(element, attribute) {
+    const value = element.attributes[attribute];
+    if (typeof value !== 'object' || Array.isArray(value))
+        return undefined;
+    const x = scalarNumber(value.x ?? value.width);
+    const y = scalarNumber(value.y ?? value.height);
+    return x === undefined || y === undefined ? undefined : { x, y };
+}
+function rootRect(graph, windowName) {
+    if (windowName === undefined)
+        return undefined;
+    const root = graph.elements.find((element) => element.name === windowName && element.parentId === undefined);
+    if (root === undefined)
+        return undefined;
+    const position = pointOrSize(root, 'position') ?? { x: 0, y: 0 };
+    const size = pointOrSize(root, 'size');
+    if (size === undefined || size.x <= 0 || size.y <= 0)
+        return undefined;
+    return { x: position.x, y: position.y, width: size.x, height: size.y };
+}
+function substantiallyOverlaps(left, right) {
+    if (left === undefined || right === undefined)
+        return false;
+    const width = Math.max(0, Math.min(left.x + left.width, right.x + right.width) - Math.max(left.x, right.x));
+    const height = Math.max(0, Math.min(left.y + left.height, right.y + right.height) - Math.max(left.y, right.y));
+    const smallerArea = Math.min(left.width * left.height, right.width * right.height);
+    return smallerArea > 0 && (width * height) / smallerArea >= 0.5;
+}
+function generatedVisibility(graph, scripted, options, random, base) {
+    const visibility = { ...base };
+    const dynamic = scripted.filter(({ visibleExpression }) => visibleExpression !== undefined);
+    if (options.visibility === 'show-all') {
+        for (const definition of dynamic)
+            visibility[definition.name] ??= true;
+        return visibility;
+    }
+    for (const definition of dynamic) {
+        if (visibility[definition.name] !== undefined)
+            continue;
+        visibility[definition.name] =
+            definition.parentScriptedGui === undefined ||
+                !transientWindowPattern.test(`${definition.name} ${definition.windowName ?? ''}`);
+    }
+    const siblingGroups = new Map();
+    for (const definition of dynamic) {
+        if (definition.parentScriptedGui === undefined)
+            continue;
+        const siblings = siblingGroups.get(definition.parentScriptedGui) ?? [];
+        siblings.push(definition);
+        siblingGroups.set(definition.parentScriptedGui, siblings);
+    }
+    for (const siblings of siblingGroups.values()) {
+        const unvisited = new Set(siblings);
+        while (unvisited.size > 0) {
+            const first = unvisited.values().next().value;
+            if (first === undefined)
+                break;
+            unvisited.delete(first);
+            const component = [first];
+            for (const current of component) {
+                for (const candidate of [...unvisited]) {
+                    if (substantiallyOverlaps(rootRect(graph, current.windowName), rootRect(graph, candidate.windowName))) {
+                        component.push(candidate);
+                        unvisited.delete(candidate);
+                    }
+                }
+            }
+            if (component.length < 2)
+                continue;
+            const selectable = component.filter((definition) => !transientWindowPattern.test(`${definition.name} ${definition.windowName ?? ''}`));
+            const selected = random.pick(selectable.length === 0 ? component : selectable);
+            for (const definition of component) {
+                if (base[definition.name] === undefined)
+                    visibility[definition.name] = definition === selected;
+            }
+        }
+    }
+    const visiblePageNames = dynamic
+        .filter(({ name }) => visibility[name] === true)
+        .flatMap(({ name, windowName: visibleWindowName }) => [name, visibleWindowName ?? ''])
+        .map((name) => name.toLocaleLowerCase('en-US'));
+    const triggerVisibilityTargets = [
+        ...new Set(scripted.flatMap(({ triggerDefinitions }) => triggerDefinitions
+            .filter(({ name }) => name.endsWith('_visible'))
+            .map(({ elementName }) => elementName))),
+    ];
+    const triggerGroups = new Map();
+    for (const target of triggerVisibilityTargets) {
+        const key = target.replace(/_(?:active|disabled|enabled|idle|off|on|selected|unselected)$/iu, '');
+        const group = triggerGroups.get(key) ?? [];
+        group.push(target);
+        triggerGroups.set(key, group);
+    }
+    for (const [baseName, targets] of triggerGroups) {
+        if (targets.length === 1) {
+            visibility[targets[0]] ??= !transientWindowPattern.test(targets[0]);
+            continue;
+        }
+        const topic = baseName.replace(/_(?:tab_)?button$/iu, '').toLocaleLowerCase('en-US');
+        const pageSelected = visiblePageNames.some((name) => name.includes(topic));
+        const preferredSuffix = pageSelected
+            ? /_(?:active|on|selected)$/iu
+            : /_(?:idle|off|unselected)$/iu;
+        const preferred = targets.find((target) => preferredSuffix.test(target)) ?? random.pick(targets);
+        for (const target of targets)
+            if (base[target] === undefined)
+                visibility[target] = target === preferred;
+    }
+    return visibility;
 }
 function generatedRows(count, random, options) {
+    const countryOffset = random.integer(0, countryNames.length - 1);
     return Array.from({ length: count }, (_unused, index) => {
-        const name = plausibleText('GetName', random, options.textSamples);
+        const countryIndex = (countryOffset + index) % countryNames.length;
+        const name = countryNames[countryIndex];
         const value = generatedNumber(options, random);
         return {
             index: index + 1,
@@ -132,70 +405,131 @@ function generatedRows(count, random, options) {
             label: name,
             name,
             GetName: name,
+            GetAdjective: countryAdjectives[countryIndex],
             value,
             amount: value,
             percentage: Math.max(0, Math.min(100, value)),
             selected: index === 0,
-            enabled: random.boolean(options.trueProbability),
+            enabled: true,
         };
     });
 }
 export function generateGuiPreviewScenarios(graph, windowName, base, options) {
     if (!options.enabled)
         return [];
-    const elements = relevantElements(graph, windowName);
-    const scripted = graph.scriptedGuis.filter((definition) => definition.windowName === windowName || definition.parentWindowName === windowName);
-    const tokens = dynamicTokens(sourceTexts(graph, elements, base.language, scripted));
+    const scripted = relatedScriptedGuis(graph, windowName);
+    const elements = relevantElements(graph, windowName, scripted);
+    const tokens = tokensIn(sourceTexts(graph, elements, base.language, scripted));
+    const imageTokens = new Set();
+    const booleanTokens = new Set();
+    const frameTokens = new Set();
+    for (const definition of scripted) {
+        for (const property of definition.propertyDefinitions) {
+            for (const [attribute, expression] of Object.entries(property.attributes)) {
+                const token = expressionToken(expression);
+                if (token === undefined)
+                    continue;
+                const normalized = attribute.toLocaleLowerCase('en-US');
+                if (normalized === 'image')
+                    imageTokens.add(token);
+                else if (normalized === 'visible' || normalized === 'enabled')
+                    booleanTokens.add(token);
+                else if (normalized === 'frame')
+                    frameTokens.add(token);
+                else
+                    tokensIn(stringsIn(expression)).numeric.forEach((value) => tokens.numeric.add(value));
+            }
+        }
+    }
+    for (const token of [...imageTokens, ...booleanTokens, ...frameTokens]) {
+        tokens.numeric.delete(token);
+        tokens.textual.delete(token);
+    }
+    const relevantDynamicTokens = new Set([...tokens.textual, ...imageTokens]);
+    for (const definition of graph.scriptedLocalisation) {
+        if (![...relevantDynamicTokens].some((token) => token === definition.name || token.endsWith(`.${definition.name}`)))
+            continue;
+        for (const choice of definition.choices) {
+            const threshold = simpleThreshold(choice.triggerExpression);
+            if (threshold !== undefined)
+                tokens.numeric.add(threshold.variable);
+        }
+    }
+    const progressRanges = new Map();
+    for (const element of elements) {
+        if (!/progressbar/iu.test(element.elementType))
+            continue;
+        const minimum = scalarNumber(element.attributes.minValue) ?? 0;
+        const maximum = scalarNumber(element.attributes.maxValue) ?? 100;
+        progressRanges.set(element.name, { minimum, maximum });
+        const startValue = element.attributes.startValue;
+        if (typeof startValue === 'string' && !/^-?(?:\d+\.?\d*|\.\d+)$/u.test(startValue))
+            tokens.numeric.add(startValue);
+    }
     const dynamicLists = [...new Set(scripted.flatMap(({ dynamicLists }) => dynamicLists))].sort();
-    const visibilityTargets = new Set(scripted.flatMap((definition) => definition.propertyDefinitions
-        .filter((property) => Object.keys(property.attributes).some((key) => key.toLocaleLowerCase('en-US') === 'visible'))
-        .map(({ elementName }) => elementName)));
     const enabledTargets = new Set(scripted.flatMap((definition) => [
         ...definition.triggerDefinitions.map(({ elementName }) => elementName),
         ...definition.propertyDefinitions
             .filter((property) => Object.keys(property.attributes).some((key) => key.toLocaleLowerCase('en-US') === 'enabled'))
             .map(({ elementName }) => elementName),
     ]));
-    const spritesByName = new Map(graph.sprites.map((sprite) => [sprite.name.toLocaleLowerCase('en-US'), sprite]));
     const sourceSeed = options.seed === 'auto' ? `${windowName}:${base.id}:${hashSourceGraph(graph)}` : options.seed;
     return Array.from({ length: options.count }, (_unused, scenarioIndex) => {
         const random = new ScenarioRandom(`${sourceSeed}:${scenarioIndex}`);
         const values = { ...base.values };
         const lists = Object.fromEntries(Object.entries(base.lists).map(([key, rows]) => [key, rows.map((row) => ({ ...row }))]));
-        const visibility = { ...base.visibility };
+        const visibility = generatedVisibility(graph, scripted, options, random, base.visibility);
         const elementStates = { ...base.elementStates };
-        const selectedFrames = { ...base.selectedFrames };
+        const scopedCountries = new Map();
         for (const key of tokens.numeric)
-            setIfMissing(values, key, generatedNumber(options, random));
+            setIfMissing(values, key, generatedNumberForKey(key, options, random));
+        for (const [elementName, { minimum, maximum }] of progressRanges) {
+            const element = elements.find(({ name }) => name === elementName);
+            const startValueToken = typeof element?.attributes.startValue === 'string'
+                ? element.attributes.startValue
+                : undefined;
+            const existingElementValue = values[elementName];
+            const existingTokenValue = startValueToken === undefined ? undefined : values[startValueToken];
+            const value = typeof existingElementValue === 'number'
+                ? existingElementValue
+                : typeof existingTokenValue === 'number'
+                    ? existingTokenValue
+                    : generatedNumber(options, random, minimum, maximum);
+            setIfMissing(values, elementName, value);
+            if (startValueToken !== undefined)
+                setIfMissing(values, startValueToken, value);
+        }
+        for (const key of tokens.numeric) {
+            if (!key.endsWith('_bar') || base.values[key] !== undefined)
+                continue;
+            const sourceKey = key.slice(0, -'_bar'.length);
+            const sourceValue = values[sourceKey];
+            if (typeof sourceValue === 'number')
+                values[key] = sourceValue;
+        }
         for (const key of tokens.textual)
-            setIfMissing(values, key, plausibleText(key, random, options.textSamples));
-        for (const element of elements) {
-            if (values[element.name] === undefined && /progressbar/iu.test(element.elementType))
-                values[element.name] = generatedNumber(options, random);
-            if (visibilityTargets.has(element.name) && visibility[element.name] === undefined)
-                visibility[element.name] =
-                    options.visibility === 'show-all' || random.boolean(options.trueProbability);
-            elementStates[element.name] ??= enabledTargets.has(element.name)
-                ? random.boolean(options.trueProbability)
-                    ? options.elementStates === 'normal'
-                        ? 'normal'
-                        : random.pick(variedStates)
-                    : 'disabled'
-                : options.elementStates === 'normal'
-                    ? 'normal'
-                    : random.pick(variedStates);
-            const spriteName = [
-                element.attributes.spriteType,
-                element.attributes.quadTextureSprite,
-                element.attributes.background,
-            ].find((candidate) => typeof candidate === 'string');
-            const frameCount = spriteName === undefined
-                ? 1
-                : (spritesByName.get(spriteName.toLocaleLowerCase('en-US'))?.frameCount ?? 1);
-            if (Number.isFinite(frameCount) &&
-                frameCount > 1 &&
-                selectedFrames[element.name] === undefined)
-                selectedFrames[element.name] = random.integer(0, Math.trunc(frameCount) - 1);
+            setIfMissing(values, key, plausibleText(key, random, options.textSamples, scopedCountries));
+        const scriptedTextTemplates = new Map();
+        for (const key of tokens.textual) {
+            const scriptedValue = scriptedLocalisationValue(graph, key, base.language, random, 'text', values);
+            if (scriptedValue !== undefined && base.values[key] === undefined)
+                scriptedTextTemplates.set(key, scriptedValue);
+        }
+        for (let pass = 0; pass < 3; pass += 1)
+            for (const [key, template] of scriptedTextTemplates)
+                values[key] = materializeDynamicText(template, values);
+        for (const key of imageTokens) {
+            const sprite = scriptedLocalisationValue(graph, key, base.language, random, 'image', values);
+            if (sprite !== undefined)
+                setIfMissing(values, key, sprite);
+        }
+        for (const key of booleanTokens)
+            setIfMissing(values, key, random.boolean(options.trueProbability));
+        for (const key of frameTokens)
+            setIfMissing(values, key, 1);
+        if (options.elementStates === 'varied') {
+            for (const elementName of enabledTargets)
+                elementStates[elementName] ??= random.pick(variedStates);
         }
         for (const listName of dynamicLists) {
             if (lists[listName] !== undefined)
@@ -206,12 +540,11 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         return parsePreviewScenario({
             ...base,
             id: `${base.id}-${options.idPrefix}-${scenarioIndex + 1}`,
-            description: `Generated plausible scenario ${scenarioIndex + 1} (seed ${sourceSeed})`,
+            description: `Generated source-aware scenario ${scenarioIndex + 1} (seed ${sourceSeed})`,
             values,
             lists,
             visibility,
             elementStates,
-            selectedFrames,
         });
     });
 }

package/dist/hoi4_agent_tools/gui/scenario.js

@@ -204,7 +204,7 @@ export const GuiGeneratedScenarioOptionsSchema = z
         .max(64)
         .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u)
         .default('generated'),
-    preservePlaceholder: z.boolean().default(true),
+    preservePlaceholder: z.boolean().default(false),
     numericMinimum: z.number().min(-1_000_000_000).max(1_000_000_000).default(0),
     numericMaximum: z.number().min(-1_000_000_000).max(1_000_000_000).default(100),
     integerValues: z.boolean().default(true),

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

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

package/dist/hoi4_agent_tools/gui/studio.js

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

package/dist/hoi4_agent_tools/gui/validators.js

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

package/dist/hoi4_agent_tools/version.js

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

package/docs/gui.md

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

package/package.json

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

package/schemas/configuration.schema.json

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

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

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

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

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

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

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

package/schemas/focus-plan.schema.json

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

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

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

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

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

package/schemas/gui-helper.schema.json

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

package/schemas/gui-scenario.schema.json

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

package/schemas/map-operation.schema.json

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

package/schemas/operation-result.schema.json

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

package/server.json

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