hoi4-agent-tools 2.6.0 → 2.8.0

package/dist/hoi4_agent_tools/gui/renderer.js

@@ -86,10 +86,23 @@ function renderText(element, toolText) {
             (glyphLine === undefined || glyphLine.source === 'deterministic-fallback'
                 ? text.lineHeight * 0.8
                 : glyphLine.baseline);
+        const horizontalScale = glyphLine !== undefined && glyphLine.width > 0 && width > 0 ? width / glyphLine.width : 1;
+        const inlineIconMarkup = (text.inlineIcons ?? [])
+            .filter((icon) => icon.lineIndex === index)
+            .map((icon) => {
+            const iconRect = {
+                x: originX + icon.offsetX * horizontalScale,
+                y: lineTop + (text.lineHeight - icon.height) / 2,
+                width: icon.width * horizontalScale,
+                height: icon.height,
+            };
+            if (icon.sprite?.supported === true && icon.sprite.dataUri !== undefined)
+                return `<image data-inline-icon="${escapeXml(icon.token)}" ${rectAttributes(iconRect)} href="${icon.sprite.dataUri}" preserveAspectRatio="xMidYMid meet"/>`;
+            return `<g data-inline-icon-missing="${escapeXml(icon.token)}"><rect ${rectAttributes(iconRect)} fill="#331f3f" stroke="#ff42d0" stroke-width="1"/><path d="M ${finite(iconRect.x)} ${finite(iconRect.y)} L ${finite(iconRect.x + iconRect.width)} ${finite(iconRect.y + iconRect.height)} M ${finite(iconRect.x + iconRect.width)} ${finite(iconRect.y)} L ${finite(iconRect.x)} ${finite(iconRect.y + iconRect.height)}" stroke="#ff42d0"/></g>`;
+        })
+            .join('');
         const colourRuns = text.colourRuns?.[index] ?? [];
         if (colourRuns.length > 0) {
-            const runWidth = colourRuns.reduce((maximum, run) => Math.max(maximum, run.offsetX + run.width), 0);
-            const horizontalScale = runWidth > 0 && width > 0 ? width / runWidth : 1;
             return `<g data-hoi4-colour-runs="true">${colourRuns
                 .map((run) => toolText.render(run.text, {
                 x: originX + run.offsetX * horizontalScale,
@@ -100,23 +113,22 @@ function renderText(element, toolText) {
                 strokeWidth: 0.6,
                 ...(run.width > 0 ? { targetWidth: run.width * horizontalScale } : {}),
             }))
-                .join('')}</g>`;
+                .join('')}${inlineIconMarkup}</g>`;
         }
         if (glyphLine?.source === 'fontkit-path') {
-            const horizontalScale = glyphLine.width > 0 && width > 0 ? width / glyphLine.width : 1;
             return `<g data-font-sha256="${glyphLine.sourceHash}">${glyphLine.glyphs
                 .filter((glyph) => glyph.kind === 'outline')
                 .map((glyph) => `<use href="#${outlineDefinitionId(glyph.key)}" transform="translate(${finite(originX + glyph.x * horizontalScale)} ${finite(baseline + glyph.y)}) scale(${finite(glyph.scale * horizontalScale)} ${finite(-glyph.scale)})"/>`)
-                .join('')}</g>`;
+                .join('')}${inlineIconMarkup}</g>`;
         }
         if (glyphLine?.source === 'bmfont-atlas') {
-            const horizontalScale = glyphLine.width > 0 && width > 0 ? width / glyphLine.width : 1;
             return `<g data-font-sha256="${glyphLine.sourceHash}">${glyphLine.glyphs
                 .filter((glyph) => glyph.kind === 'bitmap')
                 .map((glyph) => `<use href="#${bitmapDefinitionId(glyph.key)}" transform="translate(${finite(originX + glyph.x * horizontalScale)} ${finite(baseline + glyph.y - glyphLine.baseline)}) scale(${finite(horizontalScale)} 1)"/>`)
-                .join('')}</g>`;
+                .join('')}${inlineIconMarkup}</g>`;
         }
-        return toolText.render(line, {
+        const visibleLine = line.replace(/[\uE000-\uF8FF]/gu, ' ');
+        return `<g>${toolText.render(visibleLine, {
             x: originX,
             y: baseline,
             fontSize: text.fontSize,
@@ -124,9 +136,153 @@ function renderText(element, toolText) {
             stroke: '#12151a',
             strokeWidth: 0.6,
             ...(width > 0 ? { targetWidth: width } : {}),
-        });
+        })}${inlineIconMarkup}</g>`;
     });
-    return `<g data-source-id="${escapeXml(element.sourceId)}" fill="#f5f2e8" stroke="#12151a" stroke-width="0.6" paint-order="stroke">${lines.join('')}</g>`;
+    const textClipId = `gui-text-clip-${sha256Bytes(element.id).slice(0, 20)}`;
+    const clipDefinition = text.fixedSize
+        ? `<defs><clipPath id="${textClipId}"><rect ${rectAttributes(rect)}/></clipPath></defs>`
+        : '';
+    const clip = text.fixedSize ? ` clip-path="url(#${textClipId})"` : '';
+    return `${clipDefinition}<g data-source-id="${escapeXml(element.sourceId)}" fill="#f5f2e8" stroke="#12151a" stroke-width="0.6" paint-order="stroke"${clip}>${lines.join('')}</g>`;
+}
+function renderSpriteImage(sprite, rect) {
+    if (!sprite.supported || sprite.dataUri === undefined)
+        return '';
+    return `<image ${rectAttributes(rect)} href="${sprite.dataUri}" preserveAspectRatio="none"/>`;
+}
+function renderSpriteSlice(sprite, source, destination) {
+    if (!sprite.supported ||
+        sprite.dataUri === undefined ||
+        source.width <= 0 ||
+        source.height <= 0 ||
+        destination.width <= 0 ||
+        destination.height <= 0)
+        return '';
+    return `<svg ${rectAttributes(destination)} viewBox="${finite(source.x)} ${finite(source.y)} ${finite(source.width)} ${finite(source.height)}" preserveAspectRatio="none" overflow="hidden"><image x="0" y="0" width="${finite(sprite.width)}" height="${finite(sprite.height)}" href="${sprite.dataUri}" preserveAspectRatio="none"/></svg>`;
+}
+function renderTiledSpriteSlice(element, sprite, source, destination) {
+    if (!sprite.supported ||
+        sprite.dataUri === undefined ||
+        source.width <= 0 ||
+        source.height <= 0 ||
+        destination.width <= 0 ||
+        destination.height <= 0)
+        return '';
+    const tileWidth = Math.max(1, source.width * element.scale);
+    const tileHeight = Math.max(1, source.height * element.scale);
+    const id = `gui-tile-${sha256Bytes(`${element.id}:${source.x}:${source.y}:${source.width}:${source.height}`).slice(0, 20)}`;
+    return `<defs><pattern id="${id}" patternUnits="userSpaceOnUse" x="${finite(destination.x)}" y="${finite(destination.y)}" width="${finite(tileWidth)}" height="${finite(tileHeight)}"><svg width="${finite(tileWidth)}" height="${finite(tileHeight)}" viewBox="${finite(source.x)} ${finite(source.y)} ${finite(source.width)} ${finite(source.height)}" preserveAspectRatio="none" overflow="hidden"><image x="0" y="0" width="${finite(sprite.width)}" height="${finite(sprite.height)}" href="${sprite.dataUri}" preserveAspectRatio="none"/></svg></pattern></defs><rect ${rectAttributes(destination)} fill="url(#${id})"/>`;
+}
+function renderCorneredTile(element) {
+    const sprite = element.sprite;
+    const rect = element.unclippedRect;
+    const border = element.spriteBorderSize;
+    if (sprite?.supported !== true ||
+        sprite.dataUri === undefined ||
+        border === undefined ||
+        border.width <= 0 ||
+        border.height <= 0)
+        return sprite === undefined ? '' : renderSpriteImage(sprite, rect);
+    const sourceBorderX = Math.min(border.width, sprite.width / 2);
+    const sourceBorderY = Math.min(border.height, sprite.height / 2);
+    const destinationBorderX = Math.min(sourceBorderX * element.scale, rect.width / 2);
+    const destinationBorderY = Math.min(sourceBorderY * element.scale, rect.height / 2);
+    const sourceWidths = [sourceBorderX, sprite.width - sourceBorderX * 2, sourceBorderX];
+    const sourceHeights = [sourceBorderY, sprite.height - sourceBorderY * 2, sourceBorderY];
+    const destinationWidths = [
+        destinationBorderX,
+        rect.width - destinationBorderX * 2,
+        destinationBorderX,
+    ];
+    const destinationHeights = [
+        destinationBorderY,
+        rect.height - destinationBorderY * 2,
+        destinationBorderY,
+    ];
+    const sourceXs = [0, sourceBorderX, sprite.width - sourceBorderX];
+    const sourceYs = [0, sourceBorderY, sprite.height - sourceBorderY];
+    const destinationXs = [
+        rect.x,
+        rect.x + destinationBorderX,
+        rect.x + rect.width - destinationBorderX,
+    ];
+    const destinationYs = [
+        rect.y,
+        rect.y + destinationBorderY,
+        rect.y + rect.height - destinationBorderY,
+    ];
+    const parts = [];
+    for (let row = 0; row < 3; row += 1) {
+        for (let column = 0; column < 3; column += 1) {
+            const source = {
+                x: sourceXs[column] ?? 0,
+                y: sourceYs[row] ?? 0,
+                width: sourceWidths[column] ?? 0,
+                height: sourceHeights[row] ?? 0,
+            };
+            const destination = {
+                x: destinationXs[column] ?? rect.x,
+                y: destinationYs[row] ?? rect.y,
+                width: destinationWidths[column] ?? 0,
+                height: destinationHeights[row] ?? 0,
+            };
+            parts.push(row === 1 && column === 1 && element.spriteTilingCenter === true
+                ? renderTiledSpriteSlice(element, sprite, source, destination)
+                : renderSpriteSlice(sprite, source, destination));
+        }
+    }
+    return parts.join('');
+}
+function renderProgressbar(element) {
+    const rect = element.unclippedRect;
+    const sprite = element.sprite;
+    const secondary = element.secondarySprite;
+    const ratio = Math.max(0, Math.min(1, element.progressRatio ?? 1));
+    const background = secondary === undefined ? '' : renderSpriteImage(secondary, rect);
+    if (sprite?.supported !== true || sprite.dataUri === undefined)
+        return background;
+    if (ratio <= 0)
+        return background;
+    const horizontal = element.progressHorizontal !== false;
+    const filled = horizontal
+        ? { x: rect.x, y: rect.y, width: rect.width * ratio, height: rect.height }
+        : {
+            x: rect.x,
+            y: rect.y + rect.height * (1 - ratio),
+            width: rect.width,
+            height: rect.height * ratio,
+        };
+    const source = horizontal
+        ? { x: 0, y: 0, width: sprite.width * ratio, height: sprite.height }
+        : {
+            x: 0,
+            y: sprite.height * (1 - ratio),
+            width: sprite.width,
+            height: sprite.height * ratio,
+        };
+    return `${background}${renderSpriteSlice(sprite, source, filled)}`;
+}
+function renderMaskedShield(element) {
+    const rect = element.unclippedRect;
+    const sprite = element.sprite;
+    const mask = element.secondarySprite;
+    if (sprite?.supported !== true || sprite.dataUri === undefined)
+        return '';
+    if (mask?.supported !== true || mask.dataUri === undefined)
+        return renderSpriteImage(sprite, rect);
+    const id = `gui-mask-${sha256Bytes(element.id).slice(0, 20)}`;
+    return `<defs><mask id="${id}" maskUnits="userSpaceOnUse" ${rectAttributes(rect)}><image ${rectAttributes(rect)} href="${mask.dataUri}" preserveAspectRatio="none"/></mask></defs><image ${rectAttributes(rect)} href="${sprite.dataUri}" preserveAspectRatio="none" mask="url(#${id})"/>`;
+}
+function renderElementSprite(element) {
+    if (element.sprite?.supported !== true || element.sprite.dataUri === undefined)
+        return '';
+    if (element.spriteRenderMode === 'cornered-tile')
+        return renderCorneredTile(element);
+    if (element.spriteRenderMode === 'progressbar')
+        return renderProgressbar(element);
+    if (element.spriteRenderMode === 'masked-shield')
+        return renderMaskedShield(element);
+    return renderSpriteImage(element.sprite, element.unclippedRect);
 }
 function renderBaseElement(element, clipId, toolText) {
     if (!element.visible)
@@ -135,25 +291,15 @@ function renderBaseElement(element, clipId, toolText) {
     const clip = clipId === undefined ? '' : ` clip-path="url(#${clipId})"`;
     const content = [];
     if (element.sprite?.supported === true && element.sprite.dataUri !== undefined) {
-        content.push(`<image ${rectAttributes(rect)} href="${element.sprite.dataUri}" preserveAspectRatio="none"/>`);
+        content.push(renderElementSprite(element));
     }
     else if (element.sprite !== undefined) {
         content.push(`<rect ${rectAttributes(rect)} fill="#331f3f" stroke="#ff42d0" stroke-width="1"/><path d="M ${finite(rect.x)} ${finite(rect.y)} L ${finite(rect.x + rect.width)} ${finite(rect.y + rect.height)} M ${finite(rect.x + rect.width)} ${finite(rect.y)} L ${finite(rect.x)} ${finite(rect.y + rect.height)}" stroke="#ff42d0"/>`);
     }
-    if (element.progressRatio !== undefined) {
+    if (element.progressRatio !== undefined && element.spriteRenderMode !== 'progressbar') {
         content.push(`<rect x="${finite(rect.x)}" y="${finite(rect.y)}" width="${finite(rect.width * element.progressRatio)}" height="${finite(rect.height)}" fill="#5ecf8d" fill-opacity="0.65"/>`);
     }
     content.push(renderText(element, toolText));
-    if (element.state === 'hover')
-        content.push(`<rect ${rectAttributes(rect)} fill="#fff" opacity="0.08"/>`);
-    if (element.state === 'selected' || element.state === 'active')
-        content.push(`<rect ${rectAttributes(rect)} fill="none" stroke="#ffd166" stroke-width="2"/>`);
-    if (element.state === 'locked' || element.state === 'disabled')
-        content.push(`<rect ${rectAttributes(rect)} fill="#111820" opacity="0.5"/>`);
-    if (element.state === 'warning')
-        content.push(`<rect ${rectAttributes(rect)} fill="none" stroke="#ff5d5d" stroke-width="3"/>`);
-    if (element.state === 'completed')
-        content.push(`<rect ${rectAttributes(rect)} fill="none" stroke="#5ecf8d" stroke-width="2"/>`);
     return `<g id="${escapeXml(element.id)}" data-source="${escapeXml(element.sourcePath)}" data-source-id="${escapeXml(element.sourceId)}"${clip}>${content.join('')}</g>`;
 }
 function renderOverlay(element, variant, toolText) {
@@ -299,6 +445,23 @@ function sceneLayoutEvidence(scene) {
                         ...(element.sprite.reason === undefined ? {} : { reason: element.sprite.reason }),
                     },
                 }),
+            ...(element.secondarySprite === undefined
+                ? {}
+                : {
+                    secondarySprite: {
+                        spriteName: element.secondarySprite.spriteName,
+                        texturePath: element.secondarySprite.texturePath,
+                        frame: element.secondarySprite.frame,
+                        frameCount: element.secondarySprite.frameCount,
+                        width: element.secondarySprite.width,
+                        height: element.secondarySprite.height,
+                        format: element.secondarySprite.format,
+                        supported: element.secondarySprite.supported,
+                        ...(element.secondarySprite.reason === undefined
+                            ? {}
+                            : { reason: element.secondarySprite.reason }),
+                    },
+                }),
             ...(element.text === undefined
                 ? {}
                 : {

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

@@ -54,6 +54,8 @@ const modelledElementAttributes = new Set([
     'font',
     'fontSize',
     'maxWidth',
+    'maxHeight',
+    'fixedsize',
     'format',
     'buttonText',
     'buttonFont',
@@ -65,11 +67,10 @@ const modelledElementAttributes = new Set([
     'minValue',
     'maxValue',
     'startValue',
+    'centerposition',
 ]);
 const ignoredElementAttributes = new Set([
     'margin',
-    'maxHeight',
-    'fixedsize',
     'pdx_tooltip',
     'pdx_tooltip_delayed',
     'hint_tag',
@@ -84,7 +85,6 @@ const ignoredElementAttributes = new Set([
     'smooth_scrolling',
     'borderSize',
     'stepSize',
-    'centerposition',
     'fullScreen',
     'moveable',
     'show_position',
@@ -194,6 +194,14 @@ function sizeFrom(block) {
     const height = numberScalar(size, 'height', 'y');
     return width === undefined || height === undefined ? undefined : { width, height };
 }
+function nestedSizeFrom(block, key) {
+    const nested = assignments(block).find((assignment) => assignment.key.value.toLowerCase() === key.toLowerCase() && assignment.value.type === 'block')?.value;
+    if (nested?.type !== 'block')
+        return undefined;
+    const width = numberScalar(nested, 'width', 'x');
+    const height = numberScalar(nested, 'height', 'y');
+    return width === undefined || height === undefined ? undefined : { width, height };
+}
 function raw(document, node) {
     return document.text.slice(node.start, node.end);
 }
@@ -335,7 +343,7 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                 const name = firstScalarInsensitive(child, 'name');
                 if (name !== undefined) {
                     const id = deterministicId('gui_sprite', { path: file.displayPath, name });
-                    const texturePath = firstScalarInsensitive(child, 'texturefile', 'textureFile');
+                    const texturePath = firstScalarInsensitive(child, 'texturefile', 'textureFile', 'textureFile1');
                     const texturePath2 = firstScalarInsensitive(child, 'textureFile2');
                     const staticFallback = firstScalarInsensitive(child, 'static_fallback', 'staticFallback');
                     const animationRateFps = numberScalar(child, 'animation_rate_fps');
@@ -344,6 +352,10 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                     const pauseOnLoop = numberScalar(child, 'pause_on_loop');
                     const effectFile = firstScalarInsensitive(child, 'effectFile');
                     const declaredSize = sizeFrom(child);
+                    const borderSize = nestedSizeFrom(child, 'borderSize');
+                    const tilingCenter = boolScalar(child, 'tilingCenter');
+                    const horizontal = boolScalar(child, 'horizontal');
+                    const steps = numberScalar(child, 'steps');
                     const definition = {
                         id,
                         name,
@@ -361,6 +373,10 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                         ...(effectFile === undefined ? {} : { effectFile }),
                         ...(staticFallback === undefined ? {} : { staticFallback }),
                         ...(declaredSize === undefined ? {} : { declaredSize }),
+                        ...(borderSize === undefined ? {} : { borderSize }),
+                        ...(tilingCenter === undefined ? {} : { tilingCenter }),
+                        ...(horizontal === undefined ? {} : { horizontal }),
+                        ...(steps === undefined ? {} : { steps: Math.trunc(steps) }),
                         rawSource: raw(document, assignment),
                     };
                     addDomainEntry(sprites, definition, 'sprite');
@@ -374,6 +390,19 @@ function indexSpritesAndFonts(document, file, fileNodeId, nodes, edges, sprites,
                             spriteType: definition.spriteType,
                             frameCount: definition.frameCount,
                             frameAnimated: definition.frameAnimated,
+                            ...(definition.borderSize === undefined
+                                ? {}
+                                : {
+                                    borderSize: {
+                                        width: definition.borderSize.width,
+                                        height: definition.borderSize.height,
+                                    },
+                                }),
+                            ...(definition.tilingCenter === undefined
+                                ? {}
+                                : { tilingCenter: definition.tilingCenter }),
+                            ...(definition.horizontal === undefined ? {} : { horizontal: definition.horizontal }),
+                            ...(definition.steps === undefined ? {} : { steps: definition.steps }),
                             ...(definition.animationRateFps === undefined
                                 ? {}
                                 : { animationRateFps: definition.animationRateFps }),
@@ -607,9 +636,9 @@ function indexAnimationSourceManifest(file, fileNodeId, nodes, edges, manifests,
     addEdge(edges, 'contains', fileNodeId, id, true, {}, location);
 }
 function linkAnimationSources(nodes, edges, manifests, sprites, textureNodes, frameNodes) {
-    const spritesByName = new Map(sprites.map((sprite) => [sprite.name, sprite]));
+    const spritesByName = new Map(sprites.map((sprite) => [sprite.name.toLocaleLowerCase('en-US'), sprite]));
     for (const manifest of manifests) {
-        const sprite = spritesByName.get(manifest.sprite);
+        const sprite = spritesByName.get(manifest.sprite.toLocaleLowerCase('en-US'));
         addEdge(edges, 'animation_provenance', sprite?.id ?? `sprite:${manifest.sprite}`, manifest.id, sprite !== undefined, { sprite: manifest.sprite }, manifest.location);
         const sheet = textureNodes.get(normalizeAssetPath(manifest.sheet.path));
         addEdge(edges, 'animation_sheet', manifest.id, sheet ?? `texture:${normalizeAssetPath(manifest.sheet.path)}`, sheet !== undefined, { texturePath: manifest.sheet.path }, manifest.location);
@@ -688,8 +717,8 @@ function indexDecisionEntries(document, file, nodes, pendingDecisionEdges) {
     walk(document.root);
 }
 function linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scriptedLocalisation, localisation, textureNodes, fontAssetNodes, pendingDecisionEdges) {
-    const spriteByName = new Map(sprites.map((sprite) => [sprite.name, sprite]));
-    const fontByName = new Map(fonts.map((font) => [font.name, font]));
+    const spriteByName = new Map(sprites.map((sprite) => [sprite.name.toLocaleLowerCase('en-US'), sprite]));
+    const fontByName = new Map(fonts.map((font) => [font.name.toLocaleLowerCase('en-US'), font]));
     const elementByName = new Map();
     for (const element of [...elements].sort((a, b) => a.definitionOrder - b.definitionOrder)) {
         if (!elementByName.has(element.name))
@@ -719,7 +748,7 @@ function linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scripte
             `${sprite.name}_fallback`,
         ].filter((value) => value !== undefined);
         const fallback = candidates
-            .map((name) => spriteByName.get(name))
+            .map((name) => spriteByName.get(name.toLocaleLowerCase('en-US')))
             .find((value) => value !== undefined);
         if (fallback !== undefined)
             addEdge(edges, 'static_fallback', sprite.id, fallback.id, true, {}, sprite.location);
@@ -739,12 +768,12 @@ function linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scripte
     for (const element of elements) {
         const spriteName = [element.attributes.spriteType, element.attributes.quadTextureSprite].find((value) => typeof value === 'string' && value.trim().length > 0);
         if (spriteName !== undefined) {
-            const sprite = spriteByName.get(spriteName);
+            const sprite = spriteByName.get(spriteName.toLocaleLowerCase('en-US'));
             addEdge(edges, 'uses_sprite', element.id, sprite?.id ?? `sprite:${spriteName}`, sprite !== undefined, { spriteName }, element.location);
         }
         const fontName = [element.attributes.font, element.attributes.buttonFont].find((value) => typeof value === 'string' && value.trim().length > 0);
         if (fontName !== undefined) {
-            const font = fontByName.get(fontName);
+            const font = fontByName.get(fontName.toLocaleLowerCase('en-US'));
             addEdge(edges, 'uses_font', element.id, font?.id ?? `font:${fontName}`, font !== undefined, { fontName }, element.location);
         }
         for (const key of localisationAttributeNames) {

package/dist/hoi4_agent_tools/gui/studio.js

@@ -195,7 +195,10 @@ function guiLocalisationPatterns(workspace, languages = ['l_english']) {
     ].sort((left, right) => compareCodeUnits(left, right));
 }
 function normalizedAssetReference(value) {
-    const normalized = value.replaceAll('\\', '/').replace(/^\/+|^\.\//u, '');
+    const normalized = value
+        .replaceAll('\\', '/')
+        .replace(/^\/+|^\.\//u, '')
+        .replace(/\/+/gu, '/');
     return isSafeAnimationSourcePath(normalized) ? normalized : undefined;
 }
 function referenceVariants(value) {
@@ -264,29 +267,54 @@ function collectNamedAttributes(value, keys, output) {
         collectNamedAttributes(entry, keys, output);
     }
 }
+function localisationIconTokens(value) {
+    return [...value.matchAll(/£([A-Za-z0-9_.:+-]+)/gu)]
+        .map((match) => match[1])
+        .filter((token) => token !== undefined && token.length > 0);
+}
+function localisationIconSpriteCandidates(token) {
+    const normalized = token.startsWith('GFX_') ? token : `GFX_${token}`;
+    return [...new Set([normalized, `${normalized}_texticon`, `${normalized}_text_icon`])];
+}
 function referencedAssetPatternsForWindow(graph, windowName) {
     const spriteNames = new Set();
     const fontNames = new Set();
+    const textValues = new Set();
     for (const element of selectedElements(graph, windowName)) {
         collectNamedAttributes(element.attributes, new Set(['spriteType', 'quadTextureSprite']), spriteNames);
         collectNamedAttributes(element.attributes, new Set(['font', 'buttonFont']), fontNames);
+        collectNamedAttributes(element.attributes, new Set(['text', 'buttonText']), textValues);
+    }
+    for (const localisation of graph.localisation) {
+        if (textValues.has(localisation.key))
+            textValues.add(localisation.value);
     }
-    const spritesByName = new Map(graph.sprites.map((sprite) => [sprite.name, sprite]));
+    for (const value of textValues) {
+        for (const token of localisationIconTokens(value)) {
+            for (const candidate of localisationIconSpriteCandidates(token))
+                spriteNames.add(candidate);
+        }
+    }
+    const spritesByName = new Map(graph.sprites.map((sprite) => [sprite.name.toLocaleLowerCase('en-US'), sprite]));
     const selectedSprites = new Map();
     const pendingSprites = [...spriteNames];
     while (pendingSprites.length > 0) {
         const name = pendingSprites.pop();
-        if (name === undefined || selectedSprites.has(name))
+        if (name === undefined)
+            continue;
+        const key = name.toLocaleLowerCase('en-US');
+        if (selectedSprites.has(key))
             continue;
-        const sprite = spritesByName.get(name);
+        const sprite = spritesByName.get(key);
         if (sprite === undefined)
             continue;
-        selectedSprites.set(name, sprite);
+        selectedSprites.set(key, sprite);
         if (sprite.staticFallback !== undefined)
             pendingSprites.push(sprite.staticFallback);
     }
-    const selectedManifests = graph.animationSources.filter(({ sprite }) => selectedSprites.has(sprite));
-    const selectedFonts = graph.fonts.filter(({ name }) => fontNames.has(name));
+    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 references = [
         ...[...selectedSprites.values()].flatMap(({ texturePath, texturePath2 }) => [texturePath, texturePath2].filter((value) => value !== undefined)),
         ...selectedFonts.flatMap(({ assetPaths }) => assetPaths),

package/dist/hoi4_agent_tools/mcp/tools/probability.js

@@ -120,6 +120,8 @@ const analysisDataSchema = z
     cacheKey: sha256Schema,
     scenarios: nonNegativeIntegerSchema,
     candidates: nonNegativeIntegerSchema,
+    scopePools: nonNegativeIntegerSchema.optional(),
+    scopePoolCandidates: nonNegativeIntegerSchema.optional(),
     unresolved: nonNegativeIntegerSchema,
     diagnostics: nonNegativeIntegerSchema,
     sweepPoints: nonNegativeIntegerSchema.optional(),
@@ -194,6 +196,13 @@ function analysisData(result) {
         cacheKey: result.metadata.cacheKey,
         scenarios: result.scenarios.length,
         candidates: result.scenarios.reduce((sum, scenario) => sum + scenario.candidates.length, 0),
+        ...(result.scenarios.some(({ scopePools }) => (scopePools?.length ?? 0) > 0)
+            ? {
+                scopePools: result.scenarios.reduce((sum, scenario) => sum + (scenario.scopePools?.length ?? 0), 0),
+                scopePoolCandidates: result.scenarios.reduce((sum, scenario) => sum +
+                    (scenario.scopePools?.reduce((poolSum, pool) => poolSum + pool.candidates.length, 0) ?? 0), 0),
+            }
+            : {}),
         unresolved: result.unresolved.length,
         diagnostics: result.diagnostics.length,
         ...(result.sweep === undefined ? {} : { sweepPoints: result.sweep.points.length }),

package/dist/hoi4_agent_tools/probability/adapters.js

@@ -326,6 +326,11 @@ const descriptors = Object.fromEntries(Object.entries(sources).map(([id, source]
             'Apply declared external factors only after source-local operations.',
         ],
         poolNormalizationRules: normalizationRule(source.selectionRule),
+        supportedExpressions: [
+            ...source.supportedExpressions,
+            'scenario-bound ROOT/THIS/PREV/FROM scope chains, saved scopes, and event targets',
+            'declared dynamic scope-pool filters with uniform or proportional selection',
+        ],
         timingConversion: source.selectionRule === 'median_daily_hazard'
             ? [
                 'Treat the effective duration as the median of verified daily checks while active.',

package/dist/hoi4_agent_tools/probability/evaluation.js

@@ -1,6 +1,8 @@
 import { compareCodeUnits } from '../core/canonical.js';
 import { assignments } from '../core/source/index.js';
 import { Rational, sumRationals, uniformRaceProbabilities } from './rational.js';
+import { withScenarioPathValue } from './scenario-state.js';
+import { evaluateScopePools } from './scope-pools.js';
 import { evaluateTriggerBlock } from './trigger-evaluator.js';
 import { evaluateCandidateValue } from './value-evaluator.js';
 const BRANCH_LIMIT = 4_096;
@@ -305,7 +307,7 @@ function scenarioBranches(surface, scenario) {
             });
             break;
         }
-        branches = branches.flatMap((branch) => values.map((value) => ({ ...branch, state: { ...branch.state, [input.path]: value } })));
+        branches = branches.flatMap((branch) => values.map((value) => withScenarioPathValue(branch, input.path, value)));
         if (values.length > 1)
             bounded = true;
     }
@@ -599,10 +601,12 @@ export function evaluateSurfaceScenarios(surface, scenarios, definitions, horizo
             return result;
         });
         rankCandidates(candidates);
+        const scopePools = evaluateScopePools(scenario, definitions);
         const allUnresolved = [
             ...surface.unsupported,
             ...expanded.unresolved,
             ...candidates.flatMap(({ unresolved }) => unresolved),
+            ...scopePools.flatMap(({ unresolved }) => unresolved),
         ];
         const timing = horizonDays === undefined
             ? { unresolved: [] }
@@ -632,6 +636,7 @@ export function evaluateSurfaceScenarios(surface, scenarios, definitions, horizo
                             ? 'score_only'
                             : 'exact',
             candidates,
+            ...(scopePools.length === 0 ? {} : { scopePools }),
             ...(exactValues.length === candidates.length &&
                 surface.adapter.selectionRule === 'proportional_categorical'
                 ? { poolTotal: sumRationals(exactValues).toJSON() }