hoi4-agent-tools 3.0.7 → 3.0.9

package/dist/hoi4_agent_tools/core/index.js

@@ -284,6 +284,31 @@ export class SymbolIndex {
         index.finalize();
         return index;
     }
+    /** Yield between source files so protocol cancellation and progress remain responsive. */
+    static async buildAsync(files, signal) {
+        signal?.throwIfAborted();
+        const index = new SymbolIndex();
+        const definitionSelection = selectedDefinitionFiles(files);
+        for (const displayPath of definitionSelection.selected)
+            index.#definitionFiles.add(displayPath);
+        for (const skipped of definitionSelection.skipped) {
+            index.recordSkippedSource(skipped.file, skipped.diagnostics);
+        }
+        let yieldedAt = performance.now();
+        for (const file of [...files].sort((a, b) => a.loadOrder - b.loadOrder || compareCodeUnits(a.displayPath, b.displayPath))) {
+            signal?.throwIfAborted();
+            index.files.set(file.displayPath, file);
+            index.indexFile(file);
+            if (performance.now() - yieldedAt >= 20) {
+                await new Promise((resolve) => setImmediate(resolve));
+                signal?.throwIfAborted();
+                yieldedAt = performance.now();
+            }
+        }
+        index.finalize();
+        signal?.throwIfAborted();
+        return index;
+    }
     get complete() {
         return this.#complete;
     }

package/dist/hoi4_agent_tools/core/request-scheduler.js

@@ -0,0 +1,79 @@
+import { ServiceError } from './result.js';
+/** Shares execution capacity across all sessions using an engine, with fair, cancellable waits. */
+export class RequestScheduler {
+    capacity;
+    maxPending;
+    maxPendingBytes;
+    active = 0;
+    pendingBytes = 0;
+    pending = [];
+    lastOwner;
+    constructor(capacity = 2, maxPending = 1024, maxPendingBytes = 134_217_728) {
+        this.capacity = capacity;
+        this.maxPending = maxPending;
+        this.maxPendingBytes = maxPendingBytes;
+        if (!Number.isSafeInteger(capacity) || capacity < 1) {
+            throw new RangeError('Execution capacity must be a positive integer');
+        }
+    }
+    async run(owner, bytes, signal, action) {
+        signal.throwIfAborted();
+        await new Promise((resolve, reject) => {
+            if (this.pending.length >= this.maxPending ||
+                bytes > this.maxPendingBytes - this.pendingBytes) {
+                reject(new ServiceError('REQUEST_QUEUE_FULL', 'The server request queue is full; retry after current work completes'));
+                return;
+            }
+            const entry = {
+                owner,
+                bytes,
+                start: () => {
+                    signal.removeEventListener('abort', entry.cancel);
+                    this.active += 1;
+                    this.lastOwner = owner;
+                    resolve();
+                },
+                cancel: () => {
+                    const index = this.pending.indexOf(entry);
+                    if (index < 0)
+                        return;
+                    this.pending.splice(index, 1);
+                    this.pendingBytes -= bytes;
+                    signal.removeEventListener('abort', entry.cancel);
+                    reject(signal.reason instanceof Error
+                        ? signal.reason
+                        : new DOMException('Request cancelled', 'AbortError'));
+                    this.drain();
+                },
+            };
+            signal.addEventListener('abort', entry.cancel, { once: true });
+            this.pending.push(entry);
+            this.pendingBytes += bytes;
+            this.drain();
+        });
+        try {
+            signal.throwIfAborted();
+            return await action();
+        }
+        finally {
+            this.active -= 1;
+            this.drain();
+        }
+    }
+    drain() {
+        while (this.active < this.capacity && this.pending.length > 0) {
+            const other = this.pending.findIndex(({ owner }) => owner !== this.lastOwner);
+            const entry = this.pending.splice(Math.max(0, other), 1)[0];
+            // Move this session's remaining work behind every other waiting session.
+            // Merely avoiding the last owner can alternate two busy sessions forever.
+            const sameOwner = [];
+            const otherOwners = [];
+            for (const pending of this.pending) {
+                (pending.owner === entry.owner ? sameOwner : otherOwners).push(pending);
+            }
+            this.pending.splice(0, this.pending.length, ...otherOwners, ...sameOwner);
+            this.pendingBytes -= entry.bytes;
+            entry.start();
+        }
+    }
+}

package/dist/hoi4_agent_tools/core/scenario-state.js

@@ -0,0 +1,97 @@
+function caseInsensitiveEntry(record, key) {
+    if (record === undefined)
+        return undefined;
+    if (Object.hasOwn(record, key))
+        return record[key];
+    const normalized = key.toLowerCase();
+    const found = Object.entries(record).find(([candidate]) => candidate.toLowerCase() === normalized);
+    return found?.[1];
+}
+export function rootScopeContext(scenario) {
+    return {
+        expression: 'ROOT',
+        binding: {
+            id: scenario.actor ?? 'ROOT',
+            ...(scenario.actor === undefined ? {} : { actor: scenario.actor }),
+            state: scenario.state,
+            ...(scenario.flags === undefined ? {} : { flags: scenario.flags }),
+            ...(scenario.eventTargets === undefined ? {} : { eventTargets: scenario.eventTargets }),
+        },
+    };
+}
+function explicitScope(scenario, expression, parent) {
+    const binding = caseInsensitiveEntry(scenario.scopes, expression);
+    return binding === undefined ? undefined : { expression, binding, parent };
+}
+export function resolveScopeContext(scenario, expression, current) {
+    const upper = expression.toUpperCase();
+    if (upper === 'ROOT')
+        return current.expression === 'ROOT'
+            ? current
+            : { ...rootScopeContext(scenario), parent: current };
+    if (upper === 'THIS')
+        return current;
+    if (upper === 'PREV')
+        return current.parent ?? explicitScope(scenario, expression, current);
+    const chained = current.expression === 'ROOT' || current.expression === 'THIS'
+        ? expression
+        : `${current.expression}.${expression}`;
+    const chainedBinding = explicitScope(scenario, chained, current);
+    if (chainedBinding !== undefined)
+        return chainedBinding;
+    const direct = explicitScope(scenario, expression, current);
+    if (direct !== undefined)
+        return direct;
+    const targetMatch = /^(?:event_target|scope):(.+)$/iu.exec(expression);
+    const targetId = targetMatch === null
+        ? undefined
+        : (caseInsensitiveEntry(current.binding.eventTargets, targetMatch[1]) ??
+            caseInsensitiveEntry(scenario.eventTargets, targetMatch[1]));
+    if (targetId !== undefined) {
+        const declaredBinding = Object.values(scenario.scopes ?? {}).find((binding) => binding.id === targetId || binding.actor === targetId);
+        return {
+            expression,
+            binding: declaredBinding ?? { id: targetId, actor: targetId, state: {} },
+            parent: current,
+        };
+    }
+    return undefined;
+}
+export function scopeStateValue(scenario, key, current) {
+    if (Object.hasOwn(current.binding.state, key))
+        return current.binding.state[key];
+    if (Object.hasOwn(current.binding.state, `trigger.${key}`))
+        return current.binding.state[`trigger.${key}`];
+    if (current.expression !== 'ROOT')
+        return undefined;
+    if (Object.hasOwn(scenario.state, key))
+        return scenario.state[key];
+    if (Object.hasOwn(scenario.state, `trigger.${key}`))
+        return scenario.state[`trigger.${key}`];
+    return undefined;
+}
+export function rootStateValue(scenario, key) {
+    if (Object.hasOwn(scenario.state, key))
+        return scenario.state[key];
+    if (Object.hasOwn(scenario.state, `trigger.${key}`))
+        return scenario.state[`trigger.${key}`];
+    return undefined;
+}
+export function scopeIdentity(current) {
+    return current.binding.actor ?? current.binding.id;
+}
+export function scopedExpressionValue(scenario, expression) {
+    const scopes = Object.entries(scenario.scopes ?? {}).sort(([left], [right]) => right.length - left.length);
+    for (const [scope, binding] of scopes) {
+        for (const prefix of [`${scope}.`, `scope.${scope}.`, `scopes.${scope}.`]) {
+            if (!expression.toLowerCase().startsWith(prefix.toLowerCase()))
+                continue;
+            const key = expression.slice(prefix.length).replace(/^state\./u, '');
+            if (Object.hasOwn(binding.state, key))
+                return binding.state[key];
+            if (Object.hasOwn(binding.state, `variable.${key}`))
+                return binding.state[`variable.${key}`];
+        }
+    }
+    return undefined;
+}

package/dist/hoi4_agent_tools/core/shared-request-capacity.js

@@ -0,0 +1,125 @@
+import { randomUUID } from 'node:crypto';
+import { lstat, mkdir, readdir, rmdir, unlink, writeFile } from 'node:fs/promises';
+import { hostname } from 'node:os';
+import path from 'node:path';
+import { setTimeout as delay } from 'node:timers/promises';
+import { sha256Bytes } from './canonical.js';
+import { canonicalPath, containedGeneratedPath } from './workspace.js';
+import { ServiceError } from './result.js';
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== 'ESRCH';
+    }
+}
+/** Bounds heavy work across task processes sharing the same private server state. */
+export class SharedRequestCapacity {
+    stateRoot;
+    capacity;
+    constructor(stateRoot, capacity = 4) {
+        this.stateRoot = stateRoot;
+        this.capacity = capacity;
+    }
+    async run(signal, action) {
+        signal.throwIfAborted();
+        if (this.stateRoot === undefined)
+            return action();
+        const root = await containedGeneratedPath(await canonicalPath(this.stateRoot, signal), 'request-capacity', sha256Bytes(hostname().toLowerCase()).slice(0, 16));
+        await mkdir(root, { recursive: true });
+        const lease = `${process.pid}-${randomUUID()}.lease`;
+        const pendingDeletionFailures = new Map();
+        for (;;) {
+            signal.throwIfAborted();
+            for (let index = 0; index < this.capacity; index += 1) {
+                // Only the stable private parent is canonicalized. A slot can disappear during
+                // another owner's release; realpath on that ephemeral directory races on Windows.
+                // The numeric component cannot escape, and mkdir atomically proves new ownership.
+                const slot = path.join(root, String(index));
+                try {
+                    await mkdir(slot);
+                    pendingDeletionFailures.delete(index);
+                }
+                catch (error) {
+                    const code = error.code;
+                    // Windows can retain a delete-pending directory handle after rmdir
+                    // returns. Recreating that slot reports EPERM/EBUSY, not EEXIST.
+                    // No work is admitted until a later mkdir actually succeeds.
+                    if (process.platform === 'win32' && ['EPERM', 'EBUSY'].includes(code ?? '')) {
+                        const failures = (pendingDeletionFailures.get(index) ?? 0) + 1;
+                        pendingDeletionFailures.set(index, failures);
+                        if (failures >= 50)
+                            throw error;
+                        await this.reap(slot);
+                        continue;
+                    }
+                    if (code !== 'EEXIST')
+                        throw error;
+                    pendingDeletionFailures.delete(index);
+                    await this.reap(slot);
+                    continue;
+                }
+                let owner;
+                try {
+                    owner = path.join(slot, lease);
+                    await writeFile(owner, '', { flag: 'wx', mode: 0o600 });
+                }
+                catch (error) {
+                    // A competing stale-owner cleanup can remove an empty slot before our
+                    // owner file is published. No work starts until the owner exists.
+                    if (error.code === 'ENOENT')
+                        continue;
+                    await rmdir(slot).catch(() => undefined);
+                    throw error;
+                }
+                try {
+                    signal.throwIfAborted();
+                    return await action();
+                }
+                finally {
+                    await unlink(owner);
+                    await rmdir(slot).catch((error) => {
+                        const code = error.code;
+                        if (!['ENOENT', 'ENOTEMPTY'].includes(code ?? '') &&
+                            !(process.platform === 'win32' && ['EPERM', 'EBUSY'].includes(code ?? '')))
+                            throw error;
+                    });
+                }
+            }
+            await delay(100, undefined, { signal });
+        }
+    }
+    async reap(slot) {
+        try {
+            const metadata = await lstat(slot);
+            if (metadata.isSymbolicLink() || !metadata.isDirectory())
+                throw new ServiceError('PATH_GENERATED_ROOT_ESCAPE', 'Execution capacity slot must be a real directory beneath its private root');
+            const owners = await readdir(slot);
+            if (owners.length === 0) {
+                if (Date.now() - metadata.mtimeMs < 30_000)
+                    return;
+            }
+            else {
+                for (const name of owners) {
+                    const match = /^([1-9][0-9]*)-[0-9a-f-]{36}\.lease$/u.exec(name);
+                    if (match === null || processAlive(Number(match[1])))
+                        return;
+                    // Unique owner names prevent a concurrent reaper from deleting a new lease.
+                    await unlink(path.join(slot, name)).catch((error) => {
+                        if (error.code !== 'ENOENT')
+                            throw error;
+                    });
+                }
+            }
+            await rmdir(slot);
+        }
+        catch (error) {
+            const code = error.code ?? '';
+            if (!['ENOENT', 'ENOTEMPTY', 'EEXIST'].includes(code) &&
+                !(process.platform === 'win32' && ['EPERM', 'EBUSY'].includes(code)))
+                throw error;
+        }
+    }
+}

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

@@ -0,0 +1,119 @@
+import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
+import { hasBlockingDiagnostics } from '../core/diagnostics.js';
+import { evaluateTriggerBlock } from '../core/condition-evaluator.js';
+import { resolveScopeContext, rootScopeContext } from '../core/scenario-state.js';
+import { assignments, firstScalar, parseClausewitz } from '../core/source/index.js';
+/** Keep declared scoped scalars out of exploratory value generation. */
+export function guiExplicitConditionValues(base) {
+    const values = { ...base.stateValues, ...base.variables, ...base.values };
+    for (const [key, value] of Object.entries(values)) {
+        if (key.includes('.'))
+            continue;
+        values[`ROOT.${key}`] ??= value;
+        values[`THIS.${key}`] ??= value;
+    }
+    for (const [scope, binding] of Object.entries(base.scopes ?? {})) {
+        for (const [key, value] of Object.entries(binding.state)) {
+            if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean')
+                values[`${scope}.${key}`] ??= value;
+        }
+    }
+    return values;
+}
+function parsedCondition(expression) {
+    const text = expression.trim();
+    const document = parseClausewitz(Buffer.from(`condition = ${text.startsWith('{') ? text : `{ ${text} }`}`), 'scenario:condition');
+    const assignment = assignments(document.root, 'condition')[0];
+    return {
+        ...(assignment?.value.type === 'block' ? { block: assignment.value } : {}),
+        invalid: hasBlockingDiagnostics(document.diagnostics) || assignment?.value.type !== 'block',
+    };
+}
+export function guiConditionScenario(base, values = base.values) {
+    const state = { ...base.stateValues, ...base.variables, ...values };
+    for (const [key, value] of Object.entries(base.flags))
+        state[`flag.${key}`] = value;
+    const scopes = structuredClone(base.scopes ?? {});
+    for (const [key, value] of Object.entries(state)) {
+        const match = /^(ROOT|THIS|FROM(?:\.FROM)*|PREV)\.(.+)$/u.exec(key);
+        if (match === null)
+            continue;
+        if (match[1] === 'ROOT' || match[1] === 'THIS')
+            state[match[2]] ??= value;
+        else {
+            const scope = (scopes[match[1]] ??= { id: match[1], state: {} });
+            scope.state[match[2]] ??= value;
+        }
+    }
+    const actor = base.country?.tag ?? base.country?.countryTag ?? base.country?.GetTag;
+    return {
+        id: base.id,
+        state,
+        scopes,
+        closedFlags: false,
+        ...(typeof actor === 'string' ? { actor } : {}),
+    };
+}
+export function evaluateGuiCondition(expression, scenario, subject, definitions = new ClausewitzEvaluationDefinitions(), scope = 'ROOT') {
+    const context = resolveScopeContext(scenario, scope, rootScopeContext(scenario));
+    const parsed = expression === undefined ? { invalid: false } : parsedCondition(expression);
+    if (parsed.invalid || context === undefined)
+        return {
+            state: 'unresolved',
+            unresolved: [
+                {
+                    code: 'GUI_CONDITION_UNRESOLVED',
+                    message: parsed.invalid
+                        ? 'Condition could not be parsed'
+                        : `Scenario does not declare scope ${scope}`,
+                    candidateId: subject.id,
+                },
+            ],
+        };
+    return evaluateTriggerBlock(parsed.block, scenario, subject, definitions, [], context);
+}
+/** Find operands structurally for exploratory previews, without asserting branch eligibility. */
+export function guiConditionVariables(expression, definitions) {
+    if (expression === undefined)
+        return [];
+    const parsed = parsedCondition(expression);
+    if (parsed.invalid || parsed.block === undefined)
+        return [];
+    const output = new Set();
+    const visit = (block, scope, stack) => {
+        const add = (key) => {
+            // Scoped operands need actual bindings; fabricated flat values can shadow ROOT/PREV.
+            if (scope === '' &&
+                key !== undefined &&
+                !key.includes('.') &&
+                !key.startsWith('@') &&
+                !key.startsWith('constant:') &&
+                !Number.isFinite(Number(key)))
+                output.add(key);
+        };
+        for (const assignment of assignments(block)) {
+            const key = assignment.key.value;
+            if (key === 'check_variable' && assignment.value.type === 'block') {
+                const short = assignments(assignment.value).find(({ key }) => !['var', 'value', 'compare', 'tooltip'].includes(key.value));
+                add(firstScalar(assignment.value, 'var')?.value ?? short?.key.value);
+                add(firstScalar(assignment.value, 'value')?.value ??
+                    (short?.value.type === 'scalar' ? short.value.value : undefined));
+            }
+            else if (assignment.value.type === 'block') {
+                const prefix = ['ROOT', 'THIS', 'FROM', 'PREV'].includes(key) ? `${key}.` : scope;
+                visit(assignment.value, prefix, stack);
+            }
+            else if (assignment.operator.text === '>' || assignment.operator.text === '<') {
+                add(key);
+                add(assignment.value.value);
+            }
+            else {
+                const helper = definitions.scriptedTriggers.get(key);
+                if (helper !== undefined && !stack.has(key))
+                    visit(helper.value, scope, new Set([...stack, key]));
+            }
+        }
+    };
+    visit(parsed.block, '', new Set());
+    return [...output].sort();
+}

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

@@ -1,4 +1,6 @@
 import { sha256Bytes } from '../core/canonical.js';
+import { ClausewitzEvaluationDefinitions } from '../core/clausewitz-evaluation.js';
+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'];
@@ -257,70 +259,46 @@ function generatedNumberForKey(key, options, random, inferred = {}) {
 function setIfMissing(target, key, value) {
     target[key] ??= value;
 }
-function scriptedLocalisationValue(graph, token, language, random, kind, values) {
+function scriptedLocalisationValue(graph, token, language, kind, values, base, definitions, results) {
     const shortToken = token.slice(token.lastIndexOf('.') + 1);
-    const definitions = graph.scriptedLocalisation.filter(({ name }) => name === token || name === shortToken);
-    if (definitions.length === 0)
+    const definition = graph.scriptedLocalisation
+        .filter(({ name }) => name === token || name === shortToken)
+        .at(-1);
+    if (definition === undefined)
         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),
+    const scenario = guiConditionScenario(base, values);
+    const subject = {
+        id: token,
+        provenance: [
+            {
+                path: definition.sourcePath,
+                rootKind: 'source',
+                loadOrder: 0,
+                sourceHash: graph.sourceHashes[definition.sourcePath] ?? '',
+                ...(definition.location === undefined ? {} : { location: definition.location }),
+            },
+        ],
     };
-}
-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;
+    const prefix = token.includes('.') ? token.slice(0, token.lastIndexOf('.')) : 'ROOT';
+    for (const choice of definition.choices) {
+        const result = evaluateGuiCondition(choice.triggerExpression, scenario, subject, definitions, prefix);
+        results.push({
+            token,
+            sourcePath: definition.sourcePath,
+            state: result.state,
+            localisationKey: choice.localisationKey,
+            unresolved: result.unresolved.map(({ message }) => message),
+        });
+        // An earlier unknown branch may be selected by the game; a later fallback cannot prove it false.
+        if (result.state === 'unresolved')
+            return undefined;
+        if (result.state === 'false')
+            continue;
+        return kind === 'image'
+            ? choice.localisationKey
+            : localisationText(graph, language, choice.localisationKey);
+    }
+    return undefined;
 }
 function materializeDynamicText(template, values) {
     const valueFor = (key) => {
@@ -481,7 +459,7 @@ function generatedRows(count, random, options) {
         };
     });
 }
-export function generateGuiPreviewScenarios(graph, windowName, base, options) {
+export function generateGuiPreviewScenarios(graph, windowName, base, options, definitions = new ClausewitzEvaluationDefinitions()) {
     if (!options.enabled)
         return [];
     const scripted = relatedScriptedGuis(graph, windowName);
@@ -519,9 +497,8 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         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);
+            for (const variable of guiConditionVariables(choice.triggerExpression, definitions))
+                tokens.numeric.add(variable);
         }
     }
     const progressRanges = new Map();
@@ -545,7 +522,10 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
     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 explicitValues = guiExplicitConditionValues(base);
+        const values = { ...explicitValues };
+        const conditionResults = [];
+        const scriptedTokens = new Set([...tokens.textual].filter((token) => graph.scriptedLocalisation.some(({ name }) => name === token || token.endsWith(`.${name}`))));
         const lists = Object.fromEntries(Object.entries(base.lists).map(([key, rows]) => [key, rows.map((row) => ({ ...row }))]));
         const visibility = generatedVisibility(graph, scripted, options, random, base.visibility);
         const elementStates = { ...base.elementStates };
@@ -571,7 +551,7 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
                 setIfMissing(values, startValueToken, value);
         }
         for (const key of tokens.numeric) {
-            if (!key.endsWith('_bar') || base.values[key] !== undefined)
+            if (!key.endsWith('_bar') || explicitValues[key] !== undefined)
                 continue;
             const sourceKey = key.slice(0, -'_bar'.length);
             const sourceValue = values[sourceKey];
@@ -579,7 +559,7 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
                 values[key] = sourceValue;
         }
         for (const { value: valueKey, limit: limitKey } of numericConstraints.relationships) {
-            if (base.values[valueKey] !== undefined)
+            if (explicitValues[valueKey] !== undefined)
                 continue;
             const value = values[valueKey];
             const limit = values[limitKey];
@@ -589,22 +569,27 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
             values[valueKey] = Math.max(minimum, Math.min(value, limit));
         }
         for (const key of tokens.textual)
-            setIfMissing(values, key, plausibleText(key, random, options.textSamples, scopedCountries));
+            if (!scriptedTokens.has(key))
+                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)
+            if (explicitValues[key] !== undefined)
+                continue;
+            const scriptedValue = scriptedLocalisationValue(graph, key, base.language, 'text', values, base, definitions, conditionResults);
+            if (scriptedValue !== 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) {
+            if (explicitValues[key] !== undefined)
+                continue;
             if (/(?:^|\.)GetFlag$/u.test(key)) {
                 setIfMissing(values, key, generatedCountryTag);
                 continue;
             }
-            const sprite = scriptedLocalisationValue(graph, key, base.language, random, 'image', values);
+            const sprite = scriptedLocalisationValue(graph, key, base.language, 'image', values, base, definitions, conditionResults);
             if (sprite !== undefined)
                 setIfMissing(values, key, sprite);
         }
@@ -625,7 +610,8 @@ export function generateGuiPreviewScenarios(graph, windowName, base, options) {
         return parsePreviewScenario({
             ...base,
             id: `${base.id}-${options.idPrefix}-${scenarioIndex + 1}`,
-            description: `Generated source-aware scenario ${scenarioIndex + 1} (seed ${sourceSeed})`,
+            description: `Generated exploratory preview ${scenarioIndex + 1} (seed ${sourceSeed}; not verified campaign state)`,
+            conditionResults,
             values,
             country: [...imageTokens].some((key) => /(?:^|\.)GetFlag$/u.test(key))
                 ? {