hoi4-agent-tools 1.2.0 → 2.1.0

package/dist/hoi4_agent_tools/gui/inspection-artifact.js

@@ -0,0 +1,99 @@
+import { promisify } from 'node:util';
+import { gzip } from 'node:zlib';
+const gzipAsync = promisify(gzip);
+export const GUI_INSPECTION_COMPRESSION_THRESHOLD = 134_217_728;
+export const GUI_INSPECTION_FULL_GRAPH_NODE_LIMIT = 50_000;
+function isWorkspaceSource(path) {
+    return path.startsWith('mod:') || path.startsWith('fixture:');
+}
+const workspaceSeedKinds = new Set([
+    'gui_file',
+    'gfx_file',
+    'scripted_gui_file',
+    'scripted_localisation_file',
+    'gui_element',
+    'sprite',
+    'texture',
+    'font',
+    'scripted_gui',
+    'scripted_localisation',
+    'animation_source_manifest',
+    'animation_source_frame',
+]);
+function isWorkspaceGraphSeed(node) {
+    return isWorkspaceSource(node.path) && workspaceSeedKinds.has(node.kind);
+}
+function graphCounts(graph) {
+    return {
+        nodes: graph.nodes.length,
+        edges: graph.edges.length,
+        elements: graph.elements.length,
+        sprites: graph.sprites.length,
+        fonts: graph.fonts.length,
+        scriptedGuis: graph.scriptedGuis.length,
+        animationSources: graph.animationSources.length,
+        scriptedLocalisation: graph.scriptedLocalisation.length,
+        localisation: graph.localisation.length,
+    };
+}
+/**
+ * A complete vanilla GUI inventory is useful for linking but wasteful to repeat in every
+ * artifact. Large reports retain the workspace overlay, the selected scene, and every
+ * directly connected node while recording exact full-inventory counts.
+ */
+export function projectGuiGraphForArtifact(graph, selectedSourceIds = [], fullGraphNodeLimit = GUI_INSPECTION_FULL_GRAPH_NODE_LIMIT) {
+    if (graph.nodes.length <= fullGraphNodeLimit)
+        return { graph };
+    const retainedIds = new Set(selectedSourceIds);
+    for (const node of graph.nodes)
+        if (isWorkspaceGraphSeed(node))
+            retainedIds.add(node.id);
+    const retainedEdges = graph.edges.filter(({ from, to }) => retainedIds.has(from) || retainedIds.has(to));
+    for (const edge of retainedEdges) {
+        retainedIds.add(edge.from);
+        retainedIds.add(edge.to);
+    }
+    const retainedLocalisation = new Set(graph.nodes
+        .filter(({ id, kind }) => kind === 'localisation' && retainedIds.has(id))
+        .map(({ name, path }) => `${path}\u0000${name}`));
+    const retainedGraph = {
+        ...graph,
+        nodes: graph.nodes.filter(({ id }) => retainedIds.has(id)),
+        edges: retainedEdges,
+        elements: graph.elements.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
+        sprites: graph.sprites.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
+        fonts: graph.fonts.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
+        scriptedGuis: graph.scriptedGuis.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
+        animationSources: graph.animationSources.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
+        scriptedLocalisation: graph.scriptedLocalisation.filter(({ id, sourcePath }) => retainedIds.has(id) || isWorkspaceSource(sourcePath)),
+        localisation: graph.localisation.filter(({ key, sourcePath }) => retainedLocalisation.has(`${sourcePath}\u0000${key}`)),
+    };
+    return {
+        graph: retainedGraph,
+        projection: {
+            mode: 'workspace-overlay-and-selected',
+            fullCounts: graphCounts(graph),
+            returnedCounts: graphCounts(retainedGraph),
+        },
+    };
+}
+/** Keeps small reports directly readable and compresses very large source graphs deterministically. */
+export async function encodeGuiInspectionArtifact(name, json, compressionThreshold = GUI_INSPECTION_COMPRESSION_THRESHOLD) {
+    const uncompressedBytes = Buffer.byteLength(json);
+    if (uncompressedBytes <= compressionThreshold) {
+        return {
+            name,
+            mimeType: 'application/json',
+            content: json,
+            compressed: false,
+            uncompressedBytes,
+        };
+    }
+    return {
+        name: `${name}.gz`,
+        mimeType: 'application/gzip',
+        content: await gzipAsync(Buffer.from(json), { level: 1 }),
+        compressed: true,
+        uncompressedBytes,
+    };
+}

package/dist/hoi4_agent_tools/gui/layout.js

@@ -7,6 +7,8 @@ import { GUI_GRAPH_MAX_EDGES, GUI_GRAPH_MAX_ELEMENTS, GUI_GRAPH_MAX_NODES, GUI_S
 import { guiElementAttributeFidelity } from './source-graph.js';
 import { emptyFidelityReport } from './types.js';
 const clickableTypes = /(?:button|checkbox|editbox|scrollbar|progressbar)/iu;
+const numericDynamicPlaceholder = '[X]';
+const textDynamicPlaceholder = '[dynamic_loc]';
 const partialSpriteSemantics = {
     textSpriteType: {
         field: 'text_sprite_semantics',
@@ -40,8 +42,55 @@ function scalarString(value) {
         return String(value);
     return undefined;
 }
+const defaultTextColour = '#f5f2e8';
+const hoi4TextColours = {
+    B: '#4aa3df',
+    C: '#55d6d6',
+    G: '#56b870',
+    H: '#e7b454',
+    L: '#9aa7b3',
+    M: '#d16bd4',
+    O: '#e58b3c',
+    R: '#e05a5a',
+    T: '#4bc6b9',
+    W: defaultTextColour,
+    Y: '#f1c75b',
+    b: '#4aa3df',
+    g: '#87939e',
+};
 function visibleHoiText(value) {
-    return value.replace(/\u00a7[A-Za-z0-9!]/gu, '').replace(/\u00a3[^\u00a3\s]+/gu, '\u25c6');
+    const characters = [];
+    const colours = [];
+    let colour;
+    let hasColourMarkup = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index] ?? '';
+        const next = value[index + 1];
+        if (character === '\u00a7' && next !== undefined && /^[A-Za-z0-9!]$/u.test(next)) {
+            hasColourMarkup = true;
+            colour = next === '!' ? undefined : hoi4TextColours[next];
+            index += 1;
+            continue;
+        }
+        if (character === '\u00a3') {
+            let cursor = index + 1;
+            while (cursor < value.length && !/[\s\u00a3]/u.test(value[cursor] ?? ''))
+                cursor += 1;
+            characters.push('\u25c6');
+            colours.push(colour);
+            index = cursor - 1;
+            continue;
+        }
+        if (character === '\\' && next === 'n') {
+            characters.push('\n');
+            colours.push(colour);
+            index += 1;
+            continue;
+        }
+        characters.push(character);
+        colours.push(colour);
+    }
+    return { text: characters.join(''), colours, hasColourMarkup };
 }
 function scalarNumber(value, reference) {
     if (typeof value === 'number')
@@ -167,13 +216,17 @@ function resolveTokenText(value, scenario, localisation, rowValues) {
         const key = match[1] ?? '';
         const replacement = rowValues?.[key] ?? scenario.variables[key] ?? scenario.scriptedGui[key];
         if (replacement === undefined) {
-            unresolved.push(`[?${key}]`);
-            return `[?${key}]`;
+            unresolved.push(match[0]);
+            return /(?:^|\.)Get[A-Za-z0-9_]+$/u.test(key)
+                ? textDynamicPlaceholder
+                : numericDynamicPlaceholder;
         }
         return String(replacement);
     }, 'GUI variable substitution');
     text = replaceTextBounded(text, /\[([A-Za-z0-9_.:-]+)\]/gu, (match) => {
         const key = match[1] ?? '';
+        if (key === 'X' || key === 'dynamic_loc')
+            return match[0];
         const countryKey = key.replace(/^(?:ROOT|This)\./u, '');
         const replacement = rowValues?.[countryKey] ??
             scenario.country?.[countryKey] ??
@@ -181,16 +234,16 @@ function resolveTokenText(value, scenario, localisation, rowValues) {
             scenario.scriptedGui[key];
         if (replacement === undefined) {
             unresolved.push(match[0]);
-            return match[0];
+            return textDynamicPlaceholder;
         }
         return String(replacement);
     }, 'GUI scope substitution');
     return { text, unresolved: [...new Set(unresolved)].sort(), missingLocalisation };
 }
-function wrapText(catalog, fontName, text, fontSize, maximumWidth, work) {
-    const paragraphs = text.replaceAll('\\n', '\n').split('\n');
+function wrapText(catalog, fontName, text, colours, fontSize, maximumWidth, work) {
     const lines = [];
     const widths = [];
+    const colourLines = [];
     const missingGlyphs = new Set();
     const retainMissingGlyphs = (values) => {
         for (const value of values) {
@@ -201,12 +254,44 @@ function wrapText(catalog, fontName, text, fontSize, maximumWidth, work) {
     };
     let lineHeight = fontSize * 1.2;
     let metricSource = 'approximation';
-    for (const paragraph of paragraphs) {
+    const commitLine = (words) => {
+        const characters = [];
+        const lineColours = [];
+        for (const [index, word] of words.entries()) {
+            if (index > 0) {
+                characters.push(' ');
+                lineColours.push(lineColours.at(-1) ?? word.colours[0]);
+            }
+            characters.push(word.text);
+            lineColours.push(...word.colours);
+        }
+        const committedText = characters.join('');
+        work.spendTextLayout('committed text line measurement');
+        const committed = catalog.measureText(fontName, committedText, fontSize);
+        lines.push(committedText);
+        widths.push(committed.width);
+        colourLines.push(lineColours);
+        retainMissingGlyphs(committed.missingGlyphs);
+        lineHeight = committed.lineHeight;
+        metricSource = committed.source;
+    };
+    let paragraphStart = 0;
+    for (let paragraphEnd = 0; paragraphEnd <= text.length; paragraphEnd += 1) {
+        if (paragraphEnd < text.length && text[paragraphEnd] !== '\n')
+            continue;
         work.spendTextLayout('text paragraph layout');
-        const words = paragraph.split(/\s+/u).filter((word) => word.length > 0);
+        const paragraph = text.slice(paragraphStart, paragraphEnd);
+        const paragraphColours = colours.slice(paragraphStart, paragraphEnd);
+        const words = [...paragraph.matchAll(/\S+/gu)].map((match) => {
+            const start = match.index;
+            const word = match[0];
+            return { text: word, colours: paragraphColours.slice(start, start + word.length) };
+        });
+        paragraphStart = paragraphEnd + 1;
         if (words.length === 0) {
             lines.push('');
             widths.push(0);
+            colourLines.push([]);
             continue;
         }
         let currentWords = [];
@@ -215,22 +300,17 @@ function wrapText(catalog, fontName, text, fontSize, maximumWidth, work) {
         let previousWordWidth = 0;
         for (const word of words) {
             work.spendTextLayout('text word measurement');
-            const measuredWord = catalog.measureText(fontName, word, fontSize);
+            const measuredWord = catalog.measureText(fontName, word.text, fontSize);
             retainMissingGlyphs(measuredWord.missingGlyphs);
             let candidateWidth = measuredWord.width;
             if (previousWord !== undefined) {
                 work.spendTextLayout('text word-boundary measurement');
-                const boundary = catalog.measureText(fontName, `${previousWord} ${word}`, fontSize);
+                const boundary = catalog.measureText(fontName, `${previousWord} ${word.text}`, fontSize);
                 retainMissingGlyphs(boundary.missingGlyphs);
                 candidateWidth = currentWidth + boundary.width - previousWordWidth;
             }
             if (maximumWidth > 0 && candidateWidth > maximumWidth && currentWords.length > 0) {
-                const committedText = currentWords.join(' ');
-                work.spendTextLayout('committed text line measurement');
-                const committed = catalog.measureText(fontName, committedText, fontSize);
-                lines.push(committedText);
-                widths.push(committed.width);
-                retainMissingGlyphs(committed.missingGlyphs);
+                commitLine(currentWords);
                 currentWords = [word];
                 currentWidth = measuredWord.width;
             }
@@ -238,26 +318,40 @@ function wrapText(catalog, fontName, text, fontSize, maximumWidth, work) {
                 currentWords.push(word);
                 currentWidth = candidateWidth;
             }
-            previousWord = word;
+            previousWord = word.text;
             previousWordWidth = measuredWord.width;
         }
-        const committedText = currentWords.join(' ');
-        work.spendTextLayout('committed text line measurement');
-        const committed = catalog.measureText(fontName, committedText, fontSize);
-        lines.push(committedText);
-        widths.push(committed.width);
-        retainMissingGlyphs(committed.missingGlyphs);
-        lineHeight = committed.lineHeight;
-        metricSource = committed.source;
+        commitLine(currentWords);
     }
     return {
         lines,
         widths,
+        colourLines,
         lineHeight,
         metricSource,
         missingGlyphs: [...missingGlyphs].sort((a, b) => a - b),
     };
 }
+function colourRunsForLine(catalog, fontName, line, colours, fontSize, work) {
+    if (!colours.some((colour) => colour !== undefined) || line.length === 0)
+        return [];
+    const runs = [];
+    let start = 0;
+    let offsetX = 0;
+    while (start < line.length) {
+        const colour = colours[start] ?? defaultTextColour;
+        let end = start + 1;
+        while (end < line.length && (colours[end] ?? defaultTextColour) === colour)
+            end += 1;
+        const text = line.slice(start, end);
+        work.spendTextLayout('localisation colour-run measurement');
+        const width = catalog.measureText(fontName, text, fontSize).width;
+        runs.push({ text, colour, offsetX, width });
+        offsetX += width;
+        start = end;
+    }
+    return runs;
+}
 function frameFor(element, sprite, scenario) {
     const frameCount = Math.max(1, sprite.frameCount);
     const selected = scenario.selectedFrames[element.name] ?? scenario.selectedFrames[sprite.name];
@@ -439,7 +533,8 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             displayText = `${displayText} — ${displayText} — ${displayText}`;
         if (state === 'missing-localisation')
             displayText = `\u00a7R${rawText}_MISSING\u00a7!`;
-        displayText = visibleHoiText(displayText);
+        const visibleText = visibleHoiText(displayText);
+        displayText = visibleText.text;
         context.work.admitText(displayText, `GUI text for ${definition.name}`);
         const fontName = scalarString(property(definition.attributes, 'font', 'buttonFont'));
         const resolvedFontMetrics = catalog.resolvedFontMetrics(fontName);
@@ -450,10 +545,13 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             16;
         const maxWidth = (scalarNumber(property(definition.attributes, 'maxWidth'), width / scale) ?? width / scale) *
             scale;
-        const wrapped = wrapText(catalog, fontName, displayText, fontSize * scale, maxWidth, context.work);
+        const wrapped = wrapText(catalog, fontName, displayText, visibleText.colours, fontSize * scale, maxWidth, context.work);
         const glyphLines = [];
         for (const line of wrapped.lines)
             glyphLines.push(await catalog.shapeText(fontName, line, fontSize * scale));
+        const colourRuns = visibleText.hasColourMarkup
+            ? wrapped.lines.map((line, index) => colourRunsForLine(catalog, fontName, line, wrapped.colourLines[index] ?? [], fontSize * scale, context.work))
+            : undefined;
         const maximumLineWidth = wrapped.widths.reduce((maximum, value) => Math.max(maximum, value), 0);
         if (width === 0)
             width = maximumLineWidth;
@@ -476,6 +574,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             overflowX: width > 0 && measuredWidth > width + 0.01,
             overflowY: height > 0 && measuredHeight > height + 0.01,
             unresolvedTokens: resolved.unresolved,
+            ...(colourRuns === undefined ? {} : { colourRuns }),
         };
         if (wrapped.metricSource === 'approximation')
             addFidelity(fidelity, 'approximated', 'font_metrics', `No supplied font metrics for ${fontName ?? '<default>'}.`, definition);

package/dist/hoi4_agent_tools/gui/renderer.js

@@ -86,6 +86,22 @@ function renderText(element, toolText) {
             (glyphLine === undefined || glyphLine.source === 'deterministic-fallback'
                 ? text.lineHeight * 0.8
                 : glyphLine.baseline);
+        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,
+                y: baseline,
+                fontSize: text.fontSize,
+                fill: run.colour,
+                stroke: '#12151a',
+                strokeWidth: 0.6,
+                ...(run.width > 0 ? { targetWidth: run.width * horizontalScale } : {}),
+            }))
+                .join('')}</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

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

@@ -736,19 +736,19 @@ 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');
+        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);
             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');
+        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);
             addEdge(edges, 'uses_font', element.id, font?.id ?? `font:${fontName}`, font !== undefined, { fontName }, element.location);
         }
-        for (const key of ['text', 'buttonText', 'pdx_tooltip', 'pdx_tooltip_delayed', 'hint_tag']) {
+        for (const key of localisationAttributeNames) {
             const value = element.attributes[key];
-            if (typeof value !== 'string')
+            if (typeof value !== 'string' || value.trim().length === 0)
                 continue;
             const entry = localisationByKey.get(value);
             addEdge(edges, 'uses_localisation', element.id, entry === undefined ? `localisation:${value}` : deterministicId('gui_loc', entry), entry !== undefined, { field: key, key: value }, element.location);
@@ -800,6 +800,24 @@ function linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scripte
         addEdge(edges, 'decision_category_entry', pending.from, target?.id ?? `scripted_gui:${pending.target}`, target !== undefined, { scriptedGui: pending.target }, pending.location);
     }
 }
+const localisationAttributeNames = [
+    'text',
+    'buttonText',
+    'pdx_tooltip',
+    'pdx_tooltip_delayed',
+    'hint_tag',
+];
+function referencedGuiLocalisationKeys(elements, scriptedLocalisation) {
+    const keys = new Set(scriptedLocalisation.flatMap(({ localisationKeys }) => localisationKeys));
+    for (const element of elements) {
+        for (const attribute of localisationAttributeNames) {
+            const value = element.attributes[attribute];
+            if (typeof value === 'string' && value.trim().length > 0)
+                keys.add(value);
+        }
+    }
+    return keys;
+}
 function skippedInventoryCouldResolve(edge, sharedIndex) {
     switch (edge.kind) {
         case 'uses_sprite':
@@ -837,6 +855,10 @@ function* referenceDiagnostics(edges) {
             edge.kind === 'animation_source_frame' ||
             (edge.kind === 'uses_font' && edge.metadata.assetPath !== undefined))
             continue;
+        if (edge.location !== undefined &&
+            !edge.location.path.startsWith('mod:') &&
+            !edge.location.path.startsWith('fixture:'))
+            continue;
         const partial = edge.partialInventory === true;
         yield {
             code: partial ? 'GUI_REFERENCE_UNRESOLVED_PARTIAL' : 'GUI_REFERENCE_UNRESOLVED',
@@ -905,6 +927,7 @@ export function buildGuiSourceGraph(files, sharedIndex) {
     const fontAssetNodes = new Map();
     const animationFrameNodes = new Map();
     const pendingDecisionEdges = [];
+    const localisationFiles = [];
     for (const file of [...activeFiles].sort((a, b) => compareCodeUnits(a.displayPath, b.displayPath))) {
         sourceHashes[file.displayPath] = file.sha256;
         if (sharedIndex.isSourceSkipped(file.displayPath))
@@ -968,28 +991,7 @@ export function buildGuiSourceGraph(files, sharedIndex) {
             }
         }
         if (kind === 'localisation_file' && fileNodeId !== undefined) {
-            const document = parseLocalisation(file.bytes, file.displayPath);
-            diagnostics.pushMany(document.diagnostics);
-            for (const entry of document.entries) {
-                const value = {
-                    key: entry.key,
-                    language: entry.language,
-                    value: entry.value,
-                    sourcePath: file.displayPath,
-                    location: locationFor(file.displayPath, document.lineIndex, entry.start, entry.end),
-                };
-                addDomainEntry(localisation, value, 'localisation');
-                const id = deterministicId('gui_loc', value);
-                addNode(nodes, {
-                    id,
-                    kind: 'localisation',
-                    name: entry.key,
-                    path: file.displayPath,
-                    ...(value.location === undefined ? {} : { location: value.location }),
-                    metadata: { language: entry.language, value: entry.value },
-                });
-                addEdge(edges, 'contains', fileNodeId, id, true, {}, value.location);
-            }
+            localisationFiles.push({ file, fileNodeId });
             continue;
         }
         if (kind === 'animation_source_manifest' && fileNodeId !== undefined) {
@@ -999,13 +1001,15 @@ export function buildGuiSourceGraph(files, sharedIndex) {
         if (kind === undefined || fileNodeId === undefined) {
             if (/\.(?:txt|gui|gfx)$/u.test(normalized)) {
                 const document = parseClausewitz(file.bytes, file.displayPath);
-                diagnostics.pushMany(document.diagnostics);
+                if (file.rootKind === 'mod' || file.rootKind === 'fixture')
+                    diagnostics.pushMany(document.diagnostics);
                 indexDecisionEntries(document, file, nodes, pendingDecisionEdges);
             }
             continue;
         }
         const document = parseClausewitz(file.bytes, file.displayPath);
-        diagnostics.pushMany(document.diagnostics);
+        if (file.rootKind === 'mod' || file.rootKind === 'fixture')
+            diagnostics.pushMany(document.diagnostics);
         if (kind === 'gui_file')
             indexGuiElements(document, file, fileNodeId, nodes, edges, elements);
         if (kind === 'gfx_file') {
@@ -1019,6 +1023,35 @@ export function buildGuiSourceGraph(files, sharedIndex) {
         }
         indexDecisionEntries(document, file, nodes, pendingDecisionEdges);
     }
+    const referencedLocalisationKeys = referencedGuiLocalisationKeys(elements, scriptedLocalisation);
+    for (const { file, fileNodeId } of localisationFiles.sort((left, right) => right.file.loadOrder - left.file.loadOrder ||
+        compareCodeUnits(left.file.displayPath, right.file.displayPath))) {
+        const document = parseLocalisation(file.bytes, file.displayPath);
+        if (file.rootKind === 'mod' || file.rootKind === 'fixture')
+            diagnostics.pushMany(document.diagnostics);
+        for (const entry of document.entries) {
+            if (!referencedLocalisationKeys.has(entry.key))
+                continue;
+            const value = {
+                key: entry.key,
+                language: entry.language,
+                value: entry.value,
+                sourcePath: file.displayPath,
+                location: locationFor(file.displayPath, document.lineIndex, entry.start, entry.end),
+            };
+            addDomainEntry(localisation, value, 'localisation');
+            const id = deterministicId('gui_loc', value);
+            addNode(nodes, {
+                id,
+                kind: 'localisation',
+                name: entry.key,
+                path: file.displayPath,
+                ...(value.location === undefined ? {} : { location: value.location }),
+                metadata: { language: entry.language, value: entry.value },
+            });
+            addEdge(edges, 'contains', fileNodeId, id, true, {}, value.location);
+        }
+    }
     linkGraph(nodes, edges, elements, sprites, fonts, scriptedGuis, scriptedLocalisation, localisation, textureNodes, fontAssetNodes, pendingDecisionEdges);
     linkAnimationSources(nodes, edges, animationSources, sprites, textureNodes, animationFrameNodes);
     markPartialReferenceEdges(edges, sharedIndex);

package/dist/hoi4_agent_tools/gui/studio.js

@@ -125,7 +125,18 @@ function under(roots, suffixes) {
         return suffixes.map((suffix) => `${normalized}/${suffix}`);
     });
 }
-function guiDefinitionPatterns(workspace, languages = ['l_english']) {
+function guiDefinitionPatterns(workspace) {
+    const roots = workspace.registration.roots;
+    return [
+        ...new Set([
+            ...under(roots.interface, ['**/*.gui', '**/*.gfx']),
+            ...under(roots.gfx, ['**/*.gfx']),
+            ...under(roots.scriptedGui, ['**/*.txt']),
+            ...staticGuiDefinitionPatterns,
+        ]),
+    ].sort((left, right) => compareCodeUnits(left, right));
+}
+function guiLocalisationPatterns(workspace, languages = ['l_english']) {
     const roots = workspace.registration.roots;
     const languageDirectories = [...new Set(languages)].map((language) => {
         if (!/^l_[a-z_]+$/u.test(language)) {
@@ -135,9 +146,6 @@ function guiDefinitionPatterns(workspace, languages = ['l_english']) {
     });
     return [
         ...new Set([
-            ...under(roots.interface, ['**/*.gui', '**/*.gfx']),
-            ...under(roots.gfx, ['**/*.gfx']),
-            ...under(roots.scriptedGui, ['**/*.txt']),
             ...under(roots.localisation, [
                 '*.{yml,yaml}',
                 ...languageDirectories.flatMap((directory) => [
@@ -145,7 +153,6 @@ function guiDefinitionPatterns(workspace, languages = ['l_english']) {
                     `${directory}/**/*.yaml`,
                 ]),
             ]),
-            ...staticGuiDefinitionPatterns,
         ]),
     ].sort((left, right) => compareCodeUnits(left, right));
 }
@@ -395,11 +402,18 @@ export class ScriptedGuiStudio {
     async scan(workspaceId, principal, signal, languages = ['l_english']) {
         signal?.throwIfAborted();
         const workspace = this.resolver.get(workspaceId, principal);
-        const snapshot = await this.engine.scan(workspaceId, { patterns: guiDefinitionPatterns(workspace, languages) }, principal, signal);
+        const [snapshot, localisationFiles] = await Promise.all([
+            this.engine.scan(workspaceId, { patterns: guiDefinitionPatterns(workspace) }, principal, signal),
+            this.scanner.scan(workspace, {
+                patterns: guiLocalisationPatterns(workspace, languages),
+                ...(signal === undefined ? {} : { signal }),
+            }),
+        ]);
         signal?.throwIfAborted();
+        const files = mergeScannedFiles(snapshot.files, localisationFiles);
         return {
-            files: snapshot.files,
-            graph: buildGuiSourceGraph(snapshot.files, snapshot.index),
+            files,
+            graph: buildGuiSourceGraph(files, snapshot.index),
         };
     }
     async scanWindow(workspaceId, windowName, principal, signal, languages = ['l_english']) {
@@ -599,6 +613,7 @@ export class ScriptedGuiStudio {
         const stored = await this.artifacts.withAtomicChunkedWrites(workspace, writes, (artifacts) => Promise.resolve([...artifacts]), input.signal);
         return {
             artifacts: stored,
+            filesScanned: scanned.graph.filesScanned,
             render,
             stateScenes,
             resolutionScenes,