hoi4-agent-tools 4.0.0 → 4.0.3

package/dist/hoi4_agent_tools/core/temporary-directories.js

@@ -0,0 +1,293 @@
+import { randomUUID } from 'node:crypto';
+import { lstatSync, readFileSync, realpathSync, rmSync } from 'node:fs';
+import { lstat, open, readFile, readdir, realpath, rm } from 'node:fs/promises';
+import { hostname } from 'node:os';
+import path from 'node:path';
+import { z } from 'zod/v4';
+const OWNER_FILE = '.hoi4-temp-owner.json';
+const SWEEP_LOCK = '.hoi4-temp-sweep.lock';
+export const TEMPORARY_MAX_BYTES = 256 * 1024 * 1024;
+export const TEMPORARY_STALE_MS = 3 * 60 * 60 * 1000;
+// Dated event evaluation directories contain retained benchmark evidence, not scratch files.
+const scratchName = /^hoi4-(?:reference-source|event-eval)-[A-Za-z0-9]{6}$/u;
+const ownerSchema = z
+    .object({
+    version: z.literal(1),
+    pid: z.number().int().positive(),
+    host: z.string().min(1).max(256),
+    token: z.uuid(),
+})
+    .strict();
+function alive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code !== 'ESRCH';
+    }
+}
+async function owner(directory, name = OWNER_FILE) {
+    const file = path.join(directory, name);
+    try {
+        const metadata = await lstat(file);
+        if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > 4096)
+            return undefined;
+        const result = ownerSchema.safeParse(JSON.parse(await readFile(file, 'utf8')));
+        return result.success ? result.data : undefined;
+    }
+    catch (error) {
+        return error.code === 'ENOENT' ? null : undefined;
+    }
+}
+async function inventory(directory) {
+    const result = { bytes: 0, modified: 0, locked: false };
+    const pending = [directory];
+    let entries = 0;
+    while (pending.length > 0) {
+        const current = pending.pop();
+        const metadata = await lstat(current);
+        if (++entries > 100_000)
+            throw new Error('Temporary directory inventory limit exceeded');
+        result.modified = Math.max(result.modified, metadata.mtimeMs, metadata.birthtimeMs);
+        if (metadata.isSymbolicLink())
+            continue;
+        if (metadata.isFile())
+            result.bytes += metadata.size;
+        else if (metadata.isDirectory()) {
+            for (const name of await readdir(current)) {
+                if (name === OWNER_FILE)
+                    continue;
+                if (/\.(?:lock|lease)$/u.test(name))
+                    result.locked = true;
+                pending.push(path.join(current, name));
+            }
+        }
+    }
+    return result;
+}
+function overlaps(left, right) {
+    const normalize = (value) => process.platform === 'win32' ? path.resolve(value).toLowerCase() : path.resolve(value);
+    const a = normalize(left);
+    const b = normalize(right);
+    const contains = (parent, child) => {
+        const relative = path.relative(parent, child);
+        return relative !== '..' && !relative.startsWith(`..${path.sep}`) && !path.isAbsolute(relative);
+    };
+    return contains(a, b) || contains(b, a);
+}
+/** Trusted startup maintenance only; never follows a junction or accepts an MCP path. */
+export async function sweepTemporaryDirectories(parent, options = {}) {
+    const now = options.now ?? Date.now();
+    const staleMs = options.staleMs ?? TEMPORARY_STALE_MS;
+    const maxBytes = options.maxBytes ?? TEMPORARY_MAX_BYTES;
+    const currentUid = options.currentUid ?? (process.platform === 'win32' ? undefined : process.geteuid?.());
+    if (!Number.isFinite(now) ||
+        !Number.isSafeInteger(staleMs) ||
+        staleMs < 0 ||
+        !Number.isSafeInteger(maxBytes) ||
+        maxBytes < 0 ||
+        (currentUid !== undefined && (!Number.isSafeInteger(currentUid) || currentUid < 0)))
+        throw new RangeError('Invalid temporary storage limits');
+    const root = await realpath(parent);
+    // A Windows runner reaches %TEMP% through an 8.3 alias; match protected roots by both spellings.
+    const protectedRoots = (await Promise.all((options.protectedRoots ?? []).map(async (protectedRoot) => {
+        try {
+            return [protectedRoot, await realpath(protectedRoot)];
+        }
+        catch {
+            return [protectedRoot];
+        }
+    }))).flat();
+    const candidates = [];
+    for (const name of (await readdir(root)).filter((name) => scratchName.test(name)).sort()) {
+        const directory = path.join(root, name);
+        if (protectedRoots.some((protectedRoot) => overlaps(directory, protectedRoot)))
+            continue;
+        try {
+            const metadata = await lstat(directory);
+            if (!metadata.isDirectory() ||
+                metadata.isSymbolicLink() ||
+                (currentUid !== undefined && metadata.uid !== currentUid) ||
+                (await realpath(directory)) !== directory)
+                continue;
+            const record = await owner(directory);
+            // An interrupted sweep must not leave a permanent lock. Malformed or live locks
+            // stay protected; only a confirmed dead local owner can relinquish its lock.
+            const previousSweep = await owner(directory, SWEEP_LOCK);
+            const deadSweep = previousSweep?.host === hostname() &&
+                !(options.isAlive ?? alive)(previousSweep.pid) &&
+                (await owner(directory, SWEEP_LOCK))?.token === previousSweep.token;
+            if (deadSweep)
+                await rm(path.join(directory, SWEEP_LOCK));
+            const data = await inventory(directory);
+            const dead = record?.host === hostname() && !(options.isAlive ?? alive)(record.pid);
+            candidates.push({
+                directory,
+                ...data,
+                eligible: !data.locked && (dead || deadSweep || (record === null && now - data.modified > staleMs)),
+            });
+        }
+        catch {
+            // Sharing violations, malformed leases and incomplete inventories fail closed.
+        }
+    }
+    let retainedBytes = candidates.reduce((sum, entry) => sum + entry.bytes, 0);
+    let removed = 0;
+    candidates.sort((a, b) => a.modified - b.modified || (a.directory < b.directory ? -1 : 1));
+    for (const entry of candidates) {
+        if (!entry.eligible || (now - entry.modified <= staleMs && retainedBytes <= maxBytes))
+            continue;
+        const lockPath = path.join(entry.directory, SWEEP_LOCK);
+        let lock;
+        let claimed = false;
+        const token = randomUUID();
+        try {
+            lock = await open(lockPath, 'wx', 0o600);
+            claimed = true;
+            await lock.writeFile(JSON.stringify({ version: 1, pid: process.pid, host: hostname(), token }));
+            const record = await owner(entry.directory);
+            if (record === undefined ||
+                (record !== null && (record.host !== hostname() || (options.isAlive ?? alive)(record.pid))))
+                continue;
+            // Check containment again immediately before recursive removal.
+            if ((await lstat(entry.directory)).isSymbolicLink() ||
+                (await realpath(entry.directory)) !== entry.directory)
+                continue;
+            if ((await owner(entry.directory, SWEEP_LOCK))?.token !== token)
+                continue;
+            await lock.close();
+            lock = undefined;
+            await rm(entry.directory, { recursive: true, force: true });
+            retainedBytes -= entry.bytes;
+            removed += 1;
+        }
+        catch {
+            // Windows may still hold a file open. Leave it for a later sweep.
+        }
+        finally {
+            await lock?.close().catch(() => undefined);
+            if (claimed && (await owner(entry.directory, SWEEP_LOCK))?.token === token)
+                await rm(lockPath, { force: true }).catch(() => undefined);
+        }
+    }
+    return { removed, retainedBytes };
+}
+/** Own only directories allocated by this process; exit cleanup never uses a prefix sweep. */
+export class TemporaryDirectoryLifetime {
+    maxBytes;
+    #owned = new Map();
+    #reservedFiles = new Map();
+    #reservedBytes = 0;
+    #onExit = () => this.disposeSync();
+    constructor(maxBytes = TEMPORARY_MAX_BYTES) {
+        this.maxBytes = maxBytes;
+        if (!Number.isSafeInteger(maxBytes) || maxBytes < 0)
+            throw new RangeError('Invalid temporary storage budget');
+        process.once('exit', this.#onExit);
+    }
+    /** Reject an oversized fixture before truncate allocates its disk blocks on Windows. */
+    assertFileSize(file, bytes) {
+        const requested = path.resolve(file);
+        // Fixture paths are canonical, so resolve an aliased parent before matching them.
+        let absolute = requested;
+        try {
+            absolute = path.join(realpathSync.native(path.dirname(requested)), path.basename(requested));
+        }
+        catch {
+            // A file in a directory that does not exist yet cannot be inside an owned fixture.
+        }
+        if (!this.paths().some((directory) => absolute.startsWith(`${directory}${path.sep}`)))
+            return;
+        if (!Number.isSafeInteger(bytes) || bytes < 0 || bytes > this.maxBytes)
+            throw new RangeError('Temporary fixture exceeds the disk budget; use a small injected limit');
+        const previous = this.#reservedFiles.get(absolute) ?? 0;
+        if (this.#reservedBytes - previous + bytes > this.maxBytes)
+            throw new RangeError('Temporary fixtures exceed the disk budget');
+        // Reserve before the caller writes, so concurrent allocations cannot oversubscribe.
+        // Failed writes remain reserved until teardown, which fails safely rather than undercounts.
+        this.#reservedBytes += bytes - previous;
+        this.#reservedFiles.set(absolute, bytes);
+    }
+    async own(directory) {
+        const canonical = await realpath(directory);
+        // The parent may be reached through an alias, such as a Windows 8.3 short name for the user
+        // profile; the fixture directory itself must be a real directory, not a link.
+        const resolved = path.resolve(directory);
+        const viaParent = path.join(await realpath(path.dirname(resolved)), path.basename(resolved));
+        if ((await lstat(directory)).isSymbolicLink() || canonical !== viaParent)
+            throw new Error('Temporary directory must be canonical and unlinked');
+        const sweepLock = path.join(canonical, SWEEP_LOCK);
+        if (await lstat(sweepLock).catch(() => undefined))
+            throw new Error('Temporary directory is being swept');
+        const token = randomUUID();
+        const handle = await open(path.join(canonical, OWNER_FILE), 'wx', 0o600);
+        try {
+            await handle.writeFile(JSON.stringify({ version: 1, pid: process.pid, host: hostname(), token }));
+            this.#owned.set(canonical, token);
+            if (await lstat(sweepLock).catch(() => undefined))
+                throw new Error('Temporary directory is being swept');
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    paths() {
+        return [...this.#owned.keys()];
+    }
+    async release(requested) {
+        let directory = requested;
+        if (!this.#owned.has(directory)) {
+            // Owned paths are canonical; a caller may still hold an 8.3 or symlinked spelling.
+            try {
+                directory = await realpath(requested);
+            }
+            catch {
+                return;
+            }
+        }
+        const token = this.#owned.get(directory);
+        if (token === undefined)
+            return;
+        if ((await owner(directory))?.token !== token) {
+            this.#owned.delete(directory);
+            this.#forgetFiles(directory);
+            return;
+        }
+        if ((await lstat(directory)).isSymbolicLink() || (await realpath(directory)) !== directory)
+            throw new Error('Temporary directory changed before cleanup');
+        await rm(directory, { recursive: true, force: true });
+        this.#owned.delete(directory);
+        this.#forgetFiles(directory);
+    }
+    #forgetFiles(directory) {
+        for (const [file, bytes] of this.#reservedFiles)
+            if (file.startsWith(`${directory}${path.sep}`)) {
+                this.#reservedBytes -= bytes;
+                this.#reservedFiles.delete(file);
+            }
+    }
+    async dispose() {
+        for (const directory of this.paths())
+            await this.release(directory);
+        process.removeListener('exit', this.#onExit);
+    }
+    disposeSync() {
+        for (const [directory, token] of this.#owned) {
+            try {
+                if (lstatSync(directory).isSymbolicLink() || realpathSync.native(directory) !== directory)
+                    continue;
+                const parsed = ownerSchema.safeParse(JSON.parse(readFileSync(path.join(directory, OWNER_FILE), 'utf8')));
+                if (parsed.success && parsed.data.token === token)
+                    rmSync(directory, { recursive: true, force: true });
+            }
+            catch {
+                // A crash or sharing violation is recovered by the next stale sweep.
+            }
+        }
+        this.#owned.clear();
+        this.#reservedFiles.clear();
+        this.#reservedBytes = 0;
+        process.removeListener('exit', this.#onExit);
+    }
+}

package/dist/hoi4_agent_tools/core/worker-exit.js

@@ -0,0 +1,80 @@
+import { totalmem } from 'node:os';
+/** Report an uncaught failure without logging its potentially private message or stack. */
+export function workerErrorMarker(error) {
+    let code;
+    try {
+        code = typeof error === 'object' && error !== null && 'code' in error ? error.code : undefined;
+    }
+    catch {
+        // Even an exceptional code getter must not prevent a bounded failure marker.
+    }
+    return `worker-error: ${typeof code === 'string' && /^[A-Z0-9_]{1,64}$/u.test(code) ? code : 'UNCLASSIFIED'}\n`;
+}
+/** Windows status codes that a crashed native module or the C runtime leaves as the exit code. */
+const WINDOWS_CRASH_CODES = new Map([
+    [0xc0000005, 'access violation'],
+    [0xc00000fd, 'native stack overflow'],
+    [0xc0000409, 'fast-fail abort'],
+    [0xc0000374, 'heap corruption'],
+    [0x80000003, 'breakpoint abort'],
+]);
+const CRASH_SIGNALS = new Set(['SIGSEGV', 'SIGABRT', 'SIGILL', 'SIGBUS', 'SIGFPE']);
+const HEAP_OOM = /JavaScript heap out of memory|Reached heap limit|Ineffective mark-compacts/iu;
+const NATIVE_OOM = /Allocation failed - process out of memory|std::bad_alloc|Array buffer allocation failed|out of memory/iu;
+function unsignedExitCode(code) {
+    return code < 0 ? code >>> 0 : code;
+}
+/** Decide, from the exit status and the worker's last stderr, why a worker stopped. */
+export function classifyWorkerExit(evidence) {
+    const status = evidence.signal === null
+        ? `exit code ${evidence.code ?? 'none'}`
+        : `signal ${evidence.signal}${evidence.code === null ? '' : `, exit code ${evidence.code}`}`;
+    if (evidence.stoppedByHost)
+        return {
+            cause: 'stopped_by_host',
+            message: `The worker was stopped by its supervising server (${status})`,
+        };
+    if (HEAP_OOM.test(evidence.stderrTail))
+        return {
+            cause: 'heap_out_of_memory',
+            message: `The worker exhausted its V8 heap limit${evidence.heapLimitMiB === undefined ? '' : ` of ${evidence.heapLimitMiB} MiB`} (${status}); narrow the request or raise jobWorkerMaxHeapMiB`,
+        };
+    if (NATIVE_OOM.test(evidence.stderrTail))
+        return {
+            cause: 'native_out_of_memory',
+            message: `The worker could not allocate native memory (${status}); close other memory-heavy processes or request fewer or smaller render variants`,
+        };
+    const crash = evidence.code === null ? undefined : WINDOWS_CRASH_CODES.get(unsignedExitCode(evidence.code));
+    if (crash !== undefined || (evidence.signal !== null && CRASH_SIGNALS.has(evidence.signal)))
+        return {
+            cause: 'native_crash',
+            message: `The worker crashed in native code${crash === undefined ? '' : ` (${crash})`} (${status}); this is not a memory-limit failure`,
+        };
+    if (evidence.signal !== null)
+        return {
+            cause: 'terminated_externally',
+            message: `The worker was terminated from outside the server (${status})`,
+        };
+    const reported = /^worker-error: ([A-Z0-9_]{1,64})$/mu.exec(evidence.stderrTail)?.[1];
+    if (reported !== undefined)
+        return {
+            cause: 'uncaught_error',
+            message: `The worker stopped on an uncaught job error ${reported} (${status}); the retained stderr log records its diagnostic code without source text`,
+        };
+    return {
+        cause: 'exited',
+        message: `The worker exited without publishing a terminal job outcome (${status})`,
+    };
+}
+const MIB = 1024 * 1024;
+const MINIMUM_DEFAULT_HEAP_MIB = 2_048;
+const MAXIMUM_DEFAULT_HEAP_MIB = 8_192;
+/**
+ * V8 heap ceiling for job workers when none is configured. Node's own default is capped at
+ * about 4 GiB, which a large GUI or event analysis can exceed on a machine with plenty of memory.
+ * A quarter of physical memory, within fixed bounds, keeps one worker from using the machine.
+ */
+export function defaultWorkerHeapMiB(physicalBytes = totalmem()) {
+    const quarter = Math.floor(physicalBytes / MIB / 4);
+    return Math.min(MAXIMUM_DEFAULT_HEAP_MIB, Math.max(MINIMUM_DEFAULT_HEAP_MIB, quarter));
+}

package/dist/hoi4_agent_tools/gui/assets.js

@@ -184,6 +184,9 @@ export class GuiAssetCatalog {
             const languageMatch = definition.languages.some((candidate) => candidate.toLocaleLowerCase('en-US') === normalizedLanguage);
             return [
                 languageMatch ? 1 : 0,
+                // A .fnt asset supplies glyphs, not a replacement for the named font's
+                // declared colour and styling. Its mod load order must not erase those.
+                definition.kind === 'bitmapfont' ? 1 : 0,
                 sourceLoadOrder.get(definition.sourcePath) ?? 0,
                 languageMatch === definition.override ? 1 : 0,
             ];

package/dist/hoi4_agent_tools/gui/dds.js

@@ -157,7 +157,11 @@ function decodeRgb(bytes, dataOffset, width, height, bitCount, pitch, masks) {
             const source = dataOffset + y * rowPitch + x * bytesPerPixel;
             const pixel = bitCount === 32
                 ? bytes.readUInt32LE(source)
-                : byte(bytes, source) | (byte(bytes, source + 1) << 8) | (byte(bytes, source + 2) << 16);
+                : bitCount === 16
+                    ? bytes.readUInt16LE(source)
+                    : byte(bytes, source) |
+                        (byte(bytes, source + 1) << 8) |
+                        (byte(bytes, source + 2) << 16);
             const target = (y * width + x) * 4;
             output[target] = extractChannel(pixel, masks[0], 0);
             output[target + 1] = extractChannel(pixel, masks[1], 0);
@@ -231,8 +235,8 @@ export function decodeDds(bytes, budget = new RenderBudget(), operationKey = `dd
     if ((flags & DDPF_RGB) === 0)
         return unsupported('non-rgb', 'The DDS is neither RGB nor a recognised compressed format.');
     const bitCount = bytes.readUInt32LE(88);
-    if (bitCount !== 24 && bitCount !== 32)
-        return unsupported(`rgb${bitCount}`, `RGB DDS bit depth ${bitCount} is unsupported; expected 24 or 32.`);
+    if (bitCount !== 16 && bitCount !== 24 && bitCount !== 32)
+        return unsupported(`rgb${bitCount}`, `RGB DDS bit depth ${bitCount} is unsupported; expected 16, 24 or 32.`);
     const masks = [
         bytes.readUInt32LE(92),
         bytes.readUInt32LE(96),
@@ -240,7 +244,7 @@ export function decodeDds(bytes, budget = new RenderBudget(), operationKey = `dd
         bytes.readUInt32LE(104),
     ];
     const output = decodeRgb(bytes, 128, width, height, bitCount, rowPitch, masks);
-    const format = bitCount === 24 ? 'rgb24' : 'rgba32';
+    const format = bitCount === 16 ? 'rgb16' : bitCount === 24 ? 'rgb24' : 'rgba32';
     return output === undefined
         ? unsupported(format, 'The DDS RGB pixel data is truncated.')
         : { width, height, data: output, format };

package/dist/hoi4_agent_tools/gui/layout.js

@@ -2,6 +2,7 @@ import { compareCodeUnits, hashCanonical } from '../core/canonical.js';
 import { assertRenderDimensions } from '../core/render-budget.js';
 import { sortDiagnostics } from '../core/diagnostics.js';
 import { ServiceError } from '../core/result.js';
+import { nativeWindowState } from './native-state.js';
 import { GuiAssetCatalog } from './assets.js';
 import { GUI_GRAPH_MAX_EDGES, GUI_GRAPH_MAX_ELEMENTS, GUI_GRAPH_MAX_NODES, GUI_SCENE_MAX_DEPTH, GUI_SCENE_MAX_ELEMENTS, GUI_SCENE_MAX_TEXT_CHARACTERS, GUI_SCENE_MAX_TEXT_LAYOUT_OPERATIONS, GUI_SCENE_MAX_WORK, GUI_TEXT_MAX_CHARACTERS, GUI_TEXT_MAX_MISSING_GLYPH_SAMPLES, } from './limits.js';
 import { guiElementAttributeFidelity } from './source-graph.js';
@@ -593,6 +594,24 @@ function anchoredCoordinate(start, span, offset, anchor) {
 function legacyRowSuffix(instanceSuffix) {
     return instanceSuffix.replace(/#list-[^#]+/gu, '');
 }
+/**
+ * Read a visibility value the way the game reads one: booleans, the script words yes/no and
+ * true/false, visible/hidden/shown, and the numbers 0 and 1. Anything else is not a decision.
+ */
+function visibilityValue(value) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number')
+        return value === 0 ? false : value === 1 ? true : undefined;
+    if (typeof value !== 'string')
+        return undefined;
+    const word = value.trim().toLowerCase();
+    if (['yes', 'true', '1', 'visible', 'shown', 'show'].includes(word))
+        return true;
+    if (['no', 'false', '0', 'hidden', 'hide'].includes(word))
+        return false;
+    return undefined;
+}
 function explicitElementVisibility(definition, scenario, rowValues) {
     const scripted = rowValues?.[`${definition.name}.visible`] ??
         scenario.values[`${definition.name}.visible`] ??
@@ -602,7 +621,14 @@ function explicitElementVisibility(definition, scenario, rowValues) {
         (definition.sourceOwnerId === undefined
             ? undefined
             : scenario.visibility[definition.sourceOwnerId]) ??
-        (typeof scripted === 'boolean' ? scripted : undefined));
+        visibilityValue(scripted));
+}
+/** Source visibility: `visible` and `show` mean shown when true, `hide` and `hidden` when false. */
+function declaredVisibility(attributes) {
+    const visible = scalarBoolean(property(attributes, 'visible', 'show'));
+    if (visible !== undefined)
+        return visible;
+    return !(scalarBoolean(property(attributes, 'hide', 'hidden')) ?? false);
 }
 function clippedByChain(chain) {
     let result;
@@ -1124,8 +1150,7 @@ async function layoutAttachedScrollbars(definition, scrollbars, owner, childOutp
                 ...(maximum === 0 ? { enabled: false } : {}),
             },
         };
-        const sourceShown = scalarBoolean(property(bar.attributes, 'visible')) ??
-            !(scalarBoolean(property(bar.attributes, 'hide', 'hidden')) ?? false);
+        const sourceShown = declaredVisibility(bar.attributes);
         barLayouts.push({
             definition: bar,
             rect: { x: coordinate(true), y: coordinate(false), width: barWidth, height: barHeight },
@@ -1253,8 +1278,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     const parentUnresolvedVisibility = parentSceneElement?.visibilityStatus === 'unresolved'
         ? parentSceneElement.visibilityStatusReason
         : undefined;
-    const declaredHidden = scalarBoolean(property(definition.attributes, 'hide', 'hidden')) ?? false;
-    const sourceVisible = scalarBoolean(property(definition.attributes, 'visible')) ?? !declaredHidden;
+    const sourceVisible = declaredVisibility(definition.attributes);
     const resolveVisibleAppearance = inheritedVisible && (explicitlyVisible ?? sourceVisible);
     const scriptedEnabled = rowValues?.[`${definition.name}.enabled`] ??
         scenario.values[`${definition.name}.enabled`] ??
@@ -2158,13 +2182,29 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
             addFidelity(fidelity, 'unresolved', 'scripted_gui_visibility', `${scripted.name}.visible requires more scenario facts; its source visibility remains unresolved.`);
         }
     }
+    // Engine-controlled branches and icon frames come from the scenario country; scripted state,
+    // then every explicit scenario value, outranks them.
+    const native = nativeWindowState(windowName, new Set(graph.elements.map(({ name }) => name)), scenario, scannedFiles);
+    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')
+            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.`);
+    }
     const layoutScenario = {
         ...scenario,
         values: {
             ...resolvedScriptedProperties,
+            ...(native?.values ?? {}),
             ...scenario.values,
         },
         visibility: {
+            ...(native?.visibility ?? {}),
             ...scriptedWindowVisibility,
             ...constantElementVisibility,
             ...scenario.visibility,