hoi4-agent-tools 4.0.3 → 4.0.5

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 ## Unreleased
 
+## 4.0.5 - 2026-10-14
+
+- Keep child anchors independent of parent `origo`, so centered native windows place their controls inside the frame.
+- Preview division and HQ branches separately and close native selector overlays by default. Existing scenario values and visibility bindings select panels explicitly.
+- Preserve dropdown button and expanded-panel boundaries, including closed visibility, settled positions, backgrounds, clipping and attached scrollbars.
+- Render background-free scroll containers using their declared viewport bounds; retain findings for explicitly disabled clipping and invalid boundaries or references.
+- Resolve public scrollbar templates despite unrelated private namesakes. Public tool schemas and dependency versions are unchanged.
+
+## 4.0.4 - 2026-10-14
+
+- Preview individual GUI windows without redundant full symbol indexes, workspace-wide asset fallback or unbound country-flag inventories; reuse condition definitions across render variants.
+- Index technology sources once across layers and scope folder rendering to definitions, layouts and unlock targets. Full inspection retains inbound grants and references.
+- Report render phases and include the last phase in worker deadline errors. Existing parsing, raster-memory, canonical-path and stale-source limits remain enforced.
+- Resolve transitive localisation `$KEY$` references across files and bounded scenario substitutions; retain diagnostics for cycles and missing runtime values.
+- Honour numeric flag presence in scalar visibility checks, matching valued-flag super-event localisation conditions.
+- Preserve supplied GUI scenarios by default; exploratory `generatedScenarios` is now opt-in. Explicit state/resolution matrices and public schema shapes are unchanged.
+- Retain regression coverage for hidden sub-windows, timed animated-sprite frames, 16-bit DDS portraits, declared font colours, worker recovery and render-memory ceilings.
+
 ## 4.0.3 - 2026-10-12
 
 - Publish the README with the supplied HOI4 MCP Server thumbnail and direct links to the demo video on YouTube.

package/dist/hoi4_agent_tools/core/clausewitz-evaluation.js

@@ -31,11 +31,13 @@ export class ClausewitzEvaluationDefinitions {
     scriptedTriggers = new Map();
     localConstants = new Map();
     static build(snapshot) {
-        const cached = definitionCache.get(snapshot);
+        const cached = definitionCache.get(snapshot.files);
         if (cached !== undefined)
             return cached;
         const result = new ClausewitzEvaluationDefinitions();
-        for (const file of snapshot.files.filter(({ shadowedBy, relativePath }) => shadowedBy === undefined && relativePath.toLowerCase().endsWith('.txt'))) {
+        for (const file of snapshot.files.filter(({ shadowedBy, relativePath, bytes }) => shadowedBy === undefined &&
+            relativePath.toLowerCase().endsWith('.txt') &&
+            bytes.includes(0x40))) {
             const document = parseClausewitz(file.bytes, file.displayPath);
             const locals = new Map();
             for (const assignment of scalarAssignments(document.root)) {
@@ -84,7 +86,7 @@ export class ClausewitzEvaluationDefinitions {
                 });
             }
         }
-        definitionCache.set(snapshot, result);
+        definitionCache.set(snapshot.files, result);
         return result;
     }
 }

package/dist/hoi4_agent_tools/core/condition-evaluator.js

@@ -286,7 +286,11 @@ function evaluateAssignmentCore(assignment, scenario, candidate, definitions, he
             : { state: value ? 'true' : 'false', unresolved: [] };
     }
     if (key === 'has_country_flag' || key === 'has_global_flag' || key === 'has_state_flag') {
-        const explicit = bool(scopeStateValue(scenario, `flag.${right}`, scopeContext));
+        const stored = key === 'has_global_flag'
+            ? (scopeStateValue(scenario, `global_flag.${right}`, scopeContext) ??
+                scopeStateValue(scenario, `flag.${right}`, scopeContext))
+            : scopeStateValue(scenario, `flag.${right}`, scopeContext);
+        const explicit = typeof stored === 'number' && Number.isFinite(stored) ? true : bool(stored);
         if (explicit !== undefined)
             return { state: explicit ? 'true' : 'false', unresolved: [] };
         const flags = key === 'has_global_flag' && scenario.globalFlags !== undefined

package/dist/hoi4_agent_tools/core/index.js

@@ -383,6 +383,17 @@ export class SymbolIndex {
             },
         });
     }
+    /** Record parser coverage without allocating symbols for a domain that builds its own graph. */
+    recordSourceCoverage(file, diagnostics) {
+        const limits = sourcePartialLimitDiagnostics(diagnostics);
+        if (limits.length > 0) {
+            this.recordSkippedSource(file, limits);
+            return false;
+        }
+        if (isWorkspaceOwnedSource(file) && file.shadowedBy === undefined)
+            this.addDiagnostics(diagnostics);
+        return true;
+    }
     addSymbol(record) {
         if (this.symbols.length >= INDEX_RECORD_LIMIT) {
             this.#complete = false;

package/dist/hoi4_agent_tools/core/job-executor.js

@@ -106,10 +106,11 @@ export class JobExecutor {
         const controller = new AbortController();
         const watchStop = new AbortController();
         let watchFailure;
+        let lastProgressMessage = claimed.record.progress?.message;
         const deadlineTimer = options.deadlineMs === undefined || operation.mutation
             ? undefined
             : setTimeout(() => {
-                watchFailure = new ServiceError('JOB_DEADLINE_EXCEEDED', 'The job ran past its deadline and was stopped; narrow its selector or limits, or raise jobDeadlineSeconds');
+                watchFailure = new ServiceError('JOB_DEADLINE_EXCEEDED', `The job ran past its deadline and was stopped${lastProgressMessage === undefined ? '' : ` during: ${lastProgressMessage.slice(0, 160)}`}; narrow its selector or limits, or raise jobDeadlineSeconds`);
                 controller.abort(watchFailure);
             }, Math.max(0, options.deadlineMs - Date.now()));
         const watch = (async () => {
@@ -136,6 +137,7 @@ export class JobExecutor {
             signal: controller.signal,
             checkpoint: claimed.record.checkpoint,
             progress: async (progress) => {
+                lastProgressMessage = progress.message;
                 await this.jobs.store.updateOwned(scope, id, owner.token, { progress }, controller.signal);
             },
             saveCheckpoint: async (checkpoint) => {

package/dist/hoi4_agent_tools/core/job-worker-host.js

@@ -309,7 +309,7 @@ export class JobWorkerHost {
                     await stopChild(child, this.stoppedByHost);
                     await this.jobs.failInterrupted(workspaceId, id, {
                         code: 'JOB_DEADLINE_EXCEEDED',
-                        message: `The job ran longer than ${jobDeadlineSeconds} seconds and was stopped; narrow its selector or limits, or raise jobDeadlineSeconds`,
+                        message: `The job ran longer than ${jobDeadlineSeconds} seconds and was stopped${record.progress === undefined ? '' : ` during: ${record.progress.message.slice(0, 160)}`}; narrow its selector or limits, or raise jobDeadlineSeconds`,
                     }, principal);
                     return;
                 }

package/dist/hoi4_agent_tools/core/render-progress.js

@@ -0,0 +1,7 @@
+export async function renderStage(input, phase) {
+    input.signal?.throwIfAborted();
+    await new Promise((resolve) => setImmediate(resolve));
+    input.signal?.throwIfAborted();
+    await input.progress?.(phase);
+    input.signal?.throwIfAborted();
+}

package/dist/hoi4_agent_tools/gui/layout.js

@@ -219,15 +219,20 @@ function resolveTokenText(value, scenario, localisation, rowValues) {
         /^[A-Za-z0-9_.-]+$/u.test(value) &&
         (value.includes('_') || value === value.toUpperCase()))
         missingLocalisation = true;
-    text = replaceTextBounded(text, /\$([A-Za-z0-9_.-]+)\$/gu, (match) => {
+    const expandTokens = (input, stack, depth) => replaceTextBounded(input, /\$([A-Za-z0-9_.-]+)\$/gu, (match) => {
         const key = match[1] ?? '';
-        const replacement = scenario.localisation[key] ?? localisation.get(key);
-        if (replacement === undefined) {
-            unresolved.push(`$${key}$`);
-            return `$${key}$`;
+        const replacement = scenario.localisation[key] ??
+            localisation.get(key) ??
+            rowValues?.[key] ??
+            scenario.values[key] ??
+            scenario.variables[key];
+        if (replacement === undefined || stack.has(key) || depth >= 16) {
+            unresolved.push(match[0]);
+            return match[0];
         }
-        return replacement;
+        return expandTokens(String(replacement), new Set([...stack, key]), depth + 1);
     }, 'GUI localisation substitution');
+    text = expandTokens(text, new Set([value]), 0);
     text = replaceTextBounded(text, /\[\?([^\]|]+)(?:\|[^\]]+)?\]/gu, (match) => {
         const key = match[1] ?? '';
         const shortKey = key.slice(key.lastIndexOf('.') + 1);
@@ -624,11 +629,12 @@ function explicitElementVisibility(definition, scenario, rowValues) {
         visibilityValue(scripted));
 }
 /** Source visibility: `visible` and `show` mean shown when true, `hide` and `hidden` when false. */
-function declaredVisibility(attributes) {
+function declaredVisibility(attributes, fallback = true) {
     const visible = scalarBoolean(property(attributes, 'visible', 'show'));
     if (visible !== undefined)
         return visible;
-    return !(scalarBoolean(property(attributes, 'hide', 'hidden')) ?? false);
+    const hidden = scalarBoolean(property(attributes, 'hide', 'hidden'));
+    return hidden === undefined ? fallback : !hidden;
 }
 function clippedByChain(chain) {
     let result;
@@ -689,7 +695,7 @@ function refreshSceneClips(context) {
     }
 }
 function attachedScrollbars(definition, context) {
-    if (!/^(?:containerwindowtype|windowtype)$/iu.test(definition.elementType))
+    if (!/^(?:containerwindowtype|windowtype|expandedwindow)$/iu.test(definition.elementType))
         return [];
     const result = [];
     const add = (candidate, horizontal, reference) => {
@@ -713,8 +719,10 @@ function attachedScrollbars(definition, context) {
     for (const horizontal of [false, true]) {
         const name = scalarString(property(definition.attributes, horizontal ? 'horizontalScrollbar' : 'verticalScrollbar'));
         if (name !== undefined) {
-            const candidate = context.elementsByName.get(name);
-            add(candidate?.parentId === undefined ? candidate : undefined, horizontal, name);
+            const candidate = context.elementsByNameCandidates
+                .get(name)
+                ?.find((element) => element.parentId === undefined);
+            add(candidate, horizontal, name);
         }
     }
     for (const id of definition.childIds) {
@@ -1213,10 +1221,13 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     const clipChain = inheritedClipChain ?? (inheritedClip === undefined ? [] : [inheritedClip]);
     const localScale = scalarNumber(property(definition.attributes, 'scale'), 1) ?? 1;
     const scale = parentScale * localScale;
-    const shownPosition = depth === 0 ? objectProperty(property(definition.attributes, 'show_position')) : undefined;
+    const expandedWindow = definition.elementType.toLowerCase() === 'expandedwindow';
+    const shownPosition = depth === 0 || expandedWindow
+        ? objectProperty(property(definition.attributes, 'show_position'))
+        : undefined;
     const position = shownPosition ?? objectProperty(property(definition.attributes, 'position'));
     if (shownPosition !== undefined) {
-        addFidelity(fidelity, 'modelled', 'window_show_position', 'The requested root window uses its declared settled show position.', definition);
+        addFidelity(fidelity, 'modelled', 'window_show_position', 'The requested window uses its declared settled show position.', definition);
     }
     const size = objectProperty(property(definition.attributes, 'size'));
     const scriptedX = rowValues?.[`${definition.name}.x`] ??
@@ -1272,13 +1283,19 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
         width = Math.max(0, parentRect.width - localX + width);
     if (height < 0)
         height = Math.max(0, parentRect.height - localY + height);
-    const explicitlyVisible = explicitElementVisibility(definition, scenario, rowValues);
+    const explicitlyVisible = explicitElementVisibility(definition, scenario, rowValues) ??
+        context.nativeVisibility.get(definition.id);
     const unresolvedVisibilityReason = context.unresolvedElementVisibility.get(definition.name);
     const parentSceneElement = parentInstanceId === undefined ? undefined : context.instancesById.get(parentInstanceId);
     const parentUnresolvedVisibility = parentSceneElement?.visibilityStatus === 'unresolved'
         ? parentSceneElement.visibilityStatusReason
         : undefined;
-    const sourceVisible = declaredVisibility(definition.attributes);
+    const dropdown = definition.parentId === undefined ? undefined : context.elementsById.get(definition.parentId);
+    const sourceVisible = declaredVisibility(definition.attributes, !expandedWindow ||
+        depth === 0 ||
+        visibilityValue(rowValues?.[`${dropdown?.name}.expanded`] ?? scenario.values[`${dropdown?.name}.expanded`]) === true);
+    if (expandedWindow)
+        addFidelity(fidelity, 'modelled', 'native_dropdown', 'Dropdown expansion is closed by default; bind <dropdown>.expanded or explicit panel visibility to show its settled position.', definition);
     const resolveVisibleAppearance = inheritedVisible && (explicitlyVisible ?? sourceVisible);
     const scriptedEnabled = rowValues?.[`${definition.name}.enabled`] ??
         scenario.values[`${definition.name}.enabled`] ??
@@ -1614,12 +1631,13 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     else if (origoAxes.vertical === 'bottom')
         y -= height;
     const unclippedRect = { x, y, width: Math.max(0, width), height: Math.max(0, height) };
-    const ownClipping = scalarBoolean(property(definition.attributes, 'clipping')) ??
-        (backgrounds.length > 0 && /(?:containerwindow|windowtype)/iu.test(definition.elementType));
     let scrollbars = attachedScrollbars(definition, context);
-    if (scrollbars.length > 0 && (!ownClipping || backgrounds.length === 0)) {
-        diagnostics.push(diagnostic('GUI_SCROLLBAR_CONTAINER_BOUNDARY_MISSING', 'warning', `Container ${definition.name} needs a background and clipping for attached scrolling.`, definition));
-        addFidelity(fidelity, 'unsupported', 'attached_scrollbar', 'The container has no active clipped background boundary.', definition);
+    const ownClipping = scalarBoolean(property(definition.attributes, 'clipping')) ??
+        ((backgrounds.length > 0 || scrollbars.length > 0) &&
+            /(?:containerwindow|windowtype|expandedwindow)/iu.test(definition.elementType));
+    if (scrollbars.length > 0 && (!ownClipping || width <= 0 || height <= 0)) {
+        diagnostics.push(diagnostic('GUI_SCROLLBAR_CONTAINER_BOUNDARY_MISSING', 'warning', `Container ${definition.name} needs a positive-sized clipping boundary for attached scrolling.`, definition));
+        addFidelity(fidelity, 'unsupported', 'attached_scrollbar', 'The container has no active clipping boundary.', definition);
         scrollbars = [];
     }
     const margin = scrollbars.length === 0 ? undefined : objectProperty(property(definition.attributes, 'margin'));
@@ -1830,10 +1848,12 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     const childDefinitions = await scrollbarChildren(definition, definition.childIds
         .map((id) => context.elementsById.get(id))
         .filter((element) => element !== undefined)
-        .filter((element) => !/^(?:containerwindowtype|windowtype)$/iu.test(definition.elementType) ||
+        .filter((element) => !/^(?:containerwindowtype|windowtype|expandedwindow)$/iu.test(definition.elementType) ||
         element.elementType.toLowerCase() !== 'extendedscrollbartype')
-        .sort((left, right) => (scalarNumber(property(left.attributes, 'priority'), 0) ?? 0) -
-        (scalarNumber(property(right.attributes, 'priority'), 0) ?? 0) ||
+        .sort((left, right) => Number(context.nativeForeground.has(left.id)) -
+        Number(context.nativeForeground.has(right.id)) ||
+        (scalarNumber(property(left.attributes, 'priority'), 0) ?? 0) -
+            (scalarNumber(property(right.attributes, 'priority'), 0) ?? 0) ||
         left.definitionOrder - right.definitionOrder), unclippedRect, scale, context, rowValues);
     const rowList = rowValues?.[`${definition.name}.list`];
     let rows = (typeof rowList === 'string' ? scenario.lists[rowList] : undefined) ??
@@ -1903,7 +1923,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
                     ...(slotWidth === undefined ? {} : { width: slotWidth }),
                     ...(slotHeight === undefined ? {} : { height: slotHeight }),
                 };
-                await layoutElement(child, shiftedParent, childClip, scale, depth + 1, context, rowSuffix(index), index, row, instanceId, origo, resolveVisibleAppearance, childClipChain);
+                await layoutElement(child, shiftedParent, childClip, scale, depth + 1, context, rowSuffix(index), index, row, instanceId, 'upper_left', resolveVisibleAppearance, childClipChain);
                 const rendered = context.instancesById.get(`${child.id}${rowSuffix(index)}`);
                 rowHeight = Math.max(rowHeight, rendered?.unclippedRect.height ?? 0);
             }
@@ -1955,7 +1975,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
                 ...(slotWidth === undefined ? {} : { width: slotWidth }),
                 ...(slotHeight === undefined ? {} : { height: slotHeight }),
             };
-            await layoutElement(template, shiftedParent, childClip, scale, depth + 1, context, rowSuffix(index), index, row, instanceId, origo, resolveVisibleAppearance, childClipChain);
+            await layoutElement(template, shiftedParent, childClip, scale, depth + 1, context, rowSuffix(index), index, row, instanceId, 'upper_left', resolveVisibleAppearance, childClipChain);
             const rendered = context.instancesById.get(`${template.id}${rowSuffix(index)}`);
             rowY += Math.max(slotHeight ?? 0, rendered?.unclippedRect.height ?? 0) + spacingY;
             renderedRows += 1;
@@ -1965,7 +1985,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     else {
         for (const child of childDefinitions) {
             context.work.spend('nested child expansion');
-            await layoutElement(child, childParentRect, childClip, scale, depth + 1, context, instanceSuffix, rowIndex, rowValues, instanceId, origo, resolveVisibleAppearance, childClipChain);
+            await layoutElement(child, childParentRect, childClip, scale, depth + 1, context, instanceSuffix, rowIndex, rowValues, instanceId, 'upper_left', resolveVisibleAppearance, childClipChain);
         }
     }
     const childOutput = context.output.slice(firstChildOutput);
@@ -2026,7 +2046,9 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
     const localisation = new Map(graph.localisation
         .filter((entry) => entry.language.toLowerCase() === scenario.language.toLowerCase() ||
         entry.language.toLowerCase() === `l_${scenario.language.toLowerCase()}`)
-        .map((entry) => [entry.key, entry.value]));
+        // Graph localisation is ordered with the active (highest-priority) definition first.
+        .map((entry) => [entry.key, entry.value])
+        .reverse());
     if (localisation.size === 0) {
         for (const entry of graph.localisation)
             if (!localisation.has(entry.key))
@@ -2058,7 +2080,7 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
     const countryFlagProperties = new Map();
     const conditionDefinitions = relevantScriptedGuiNames.size === 0
         ? undefined
-        : ClausewitzEvaluationDefinitions.build({ files: [...scannedFiles] });
+        : ClausewitzEvaluationDefinitions.build({ files: scannedFiles });
     const conditionScenario = guiConditionScenario(scenario);
     for (const scripted of graph.scriptedGuis.filter(({ name }) => relevantScriptedGuiNames.has(name))) {
         const source = scannedFiles.find(({ displayPath }) => displayPath === scripted.sourcePath);
@@ -2188,10 +2210,14 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
     if (native !== undefined) {
         for (const note of native.notes)
             addFidelity(fidelity, 'modelled', 'native_window_state', note);
-        const { sources } = native.state;
-        if (native.state.tag === undefined ||
-            sources.faction === 'default' ||
-            sources.balanceOfPower === 'default')
+        for (const note of native.approximations ?? [])
+            addFidelity(fidelity, 'approximated', 'native_window_state', note);
+        const sources = native.state?.sources;
+        if (native.state !== undefined &&
+            sources !== undefined &&
+            (native.state.tag === undefined ||
+                sources.faction === 'default' ||
+                sources.balanceOfPower === 'default'))
             addFidelity(fidelity, 'approximated', 'native_window_state', native.state.tag === undefined
                 ? 'The scenario names no country, so the window shows the state of a country in no faction and without a balance of power; set country.tag or the country faction, balanceOfPower and ideology facts.'
                 : `No history for ${native.state.tag} was available, so its faction and balance of power default to none; set country.faction, country.balanceOfPower and country.ideology to override.`);
@@ -2204,7 +2230,6 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
             ...scenario.values,
         },
         visibility: {
-            ...(native?.visibility ?? {}),
             ...scriptedWindowVisibility,
             ...constantElementVisibility,
             ...scenario.visibility,
@@ -2222,6 +2247,24 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
         elementsByNameCandidates.set(element.name, candidates);
     }
     const context = {
+        nativeForeground: new Set(graph.elements
+            .filter((element) => element.parentId === root.id && native?.foreground?.includes(element.name))
+            .map(({ id }) => id)),
+        nativeVisibility: new Map(graph.elements.flatMap((element) => {
+            const visible = native?.visibility[element.name];
+            if (visible === undefined)
+                return [];
+            // The designer reuses names (including division_title) inside selector panels.
+            // Its branch decisions apply to root controls, not identically named descendants.
+            if (windowName === 'countrydivisiondesignerview' && element.parentId !== root.id) {
+                const parent = element.parentId === undefined ? undefined : elementsById.get(element.parentId);
+                if (element.name !== 'hq_badge' ||
+                    parent?.name !== 'template_emblem_slot' ||
+                    parent.parentId !== root.id)
+                    return [];
+            }
+            return [[element.id, visible]];
+        })),
         graph,
         scenario: layoutScenario,
         catalog,

package/dist/hoi4_agent_tools/gui/native-state.js

@@ -205,13 +205,52 @@ export function resolveNativeCountryState(scenario, files) {
 }
 /** Whether any native decision can apply to this window, so the country state is worth resolving. */
 export function windowHasNativeState(windowName, elementNames) {
-    return (NATIVE_BRANCHES[windowName] !== undefined ||
+    return (windowName === 'countrydivisiondesignerview' ||
+        NATIVE_BRANCHES[windowName] !== undefined ||
         Object.keys(IDEOLOGY_FRAME_ICONS).some((name) => elementNames.has(name)));
 }
 /** The engine-selected branches and frames for a scene, below any explicit scenario input. */
 export function nativeWindowState(windowName, elementNames, scenario, files) {
     if (!windowHasNativeState(windowName, elementNames))
         return undefined;
+    if (windowName === 'countrydivisiondesignerview') {
+        const hq = scenario.values['countrydivisiondesignerview.hq'] === true;
+        const panel = scenario.values['countrydivisiondesignerview.panel'];
+        const visibility = {};
+        for (const name of ['hq_overlay_images', 'subunits_hq', 'hq_view', 'hq_title', 'hq_badge'])
+            if (elementNames.has(name))
+                visibility[name] = hq;
+        for (const name of [
+            'subunits',
+            'non_hq_view',
+            'division_title',
+            'division_composition_label',
+            'combat_width_view',
+        ])
+            if (elementNames.has(name))
+                visibility[name] = !hq;
+        const selectors = [
+            'designerregimentswindow',
+            'division_equipment_view',
+            'div_templ_custom_icon_view',
+            'div_template_select_model',
+            'niche_icon_selector',
+        ];
+        for (const name of selectors)
+            if (elementNames.has(name))
+                visibility[name] = panel === name;
+        return {
+            visibility,
+            values: {},
+            foreground: selectors,
+            notes: [
+                `Division designer uses the ${hq ? 'HQ' : 'division'} branch and only the explicitly selected native selector panel.`,
+            ],
+            approximations: [
+                'Native division state is a preview convention: defaults to a division with selectors closed. Set values countrydivisiondesignerview.hq and countrydivisiondesignerview.panel, or explicit element visibility. Engine-populated rows and statistics require scenario bindings.',
+            ],
+        };
+    }
     const state = resolveNativeCountryState(scenario, files);
     const visibility = {};
     const values = {};

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

@@ -3,7 +3,7 @@ import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.j
 import { evaluateGuiCondition, guiConditionScenario, guiConditionVariables, guiExplicitConditionValues, } from './scenario-conditions.js';
 import { parsePreviewScenario } from './scenario.js';
 const countryNames = ['Germany', 'France', 'Poland', 'Italy', 'Brazil', 'India', 'Canada'];
-const countryTags = ['GER', 'FRA', 'POL', 'ITA', 'BRA', 'RAJ', 'CAN'];
+export const generatedCountryTags = ['GER', 'FRA', 'POL', 'ITA', 'BRA', 'RAJ', 'CAN'];
 const countryIdeologies = [
     'fascism',
     'democratic',
@@ -435,7 +435,7 @@ function generatedRows(count, random, options) {
     return Array.from({ length: count }, (_unused, index) => {
         const countryIndex = (countryOffset + index) % countryNames.length;
         const name = countryNames[countryIndex];
-        const tag = countryTags[countryIndex];
+        const tag = generatedCountryTags[countryIndex];
         const ideology = countryIdeologies[countryIndex];
         const value = generatedNumber(options, random);
         return {
@@ -587,7 +587,7 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options, de
         const elementStates = { ...base.elementStates };
         const scopedCountries = new Map();
         const generatedCountryIndex = random.integer(0, countryNames.length - 1);
-        const generatedCountryTag = countryTags[generatedCountryIndex];
+        const generatedCountryTag = generatedCountryTags[generatedCountryIndex];
         for (const key of tokens.numeric)
             setIfMissing(values, key, generatedNumberForKey(key, options, random, numericConstraints.ranges.get(key)));
         for (const [elementName, { minimum, maximum }] of progressRanges) {