hoi4-agent-tools 2.8.5 → 2.8.7

package/CHANGELOG.md

@@ -4,6 +4,17 @@
 
 No unreleased changes.
 
+## 2.8.7 - 2026-08-28
+
+- Isolate stale, foreign, oversized, malformed, and address-mismatched artifact manifests so one bad generated record cannot block unrelated probability, event, GUI, or other MCP evidence routes.
+- Repair corrupted deterministic manifests from recomputed expected bytes, validate cached probability resources before reuse, and keep direct foreign-artifact access unavailable without exposing cross-workspace content.
+
+## 2.8.6 - 2026-08-28
+
+- Generate source-aware scripted-GUI scenarios from complete parent/child surfaces, real scripted-localisation candidates, simple threshold conditions, coherent tab states, scoped values, meter ranges, and dynamic-list rows while keeping explicit scenario values authoritative.
+- Preserve native HOI4 bitmap-font antialiasing and shadow pixels when applying face and localisation colours, including global and per-font `textcolors` palettes.
+- Prevent stale workspace artifacts and irrelevant language font atlases from blocking GUI calls, resolve alternate vanilla raster extensions and repeated path separators, and keep placeholder scenarios opt-in so their intentionally unresolved state does not pollute normal validation.
+
 ## 2.8.5 - 2026-08-28
 
 - Render bitmap-font face and localisation colours through alpha masks, including black source atlases, and load exact per-font HOI4 `textcolors` palettes.

package/dist/hoi4_agent_tools/core/artifacts.js

@@ -131,15 +131,50 @@ export function boundedSourceHashEvidence(sourceHashes) {
     };
 }
 function assertManifestIntegrity(manifest, expected, workspace) {
-    if (manifest.workspaceIdentity !== workspace.workspaceIdentity ||
-        manifest.ownerIdentity !== workspace.ownerIdentity ||
-        manifest.sha256 !== expected.sha256 ||
+    assertManifestAddressIntegrity(manifest, expected);
+    if (!manifestBelongsToWorkspace(manifest, workspace)) {
+        throw new ServiceError('ARTIFACT_NOT_FOUND', 'Artifact provenance manifest is unavailable');
+    }
+}
+function manifestBelongsToWorkspace(manifest, workspace) {
+    return (manifest.workspaceIdentity === workspace.workspaceIdentity &&
+        manifest.ownerIdentity === workspace.ownerIdentity);
+}
+function assertManifestAddressIntegrity(manifest, expected) {
+    if (manifest.sha256 !== expected.sha256 ||
         manifest.provenanceHash !== expected.provenanceHash ||
         manifest.name !== expected.name ||
         provenanceHashFor(manifest) !== expected.provenanceHash) {
         throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest does not match its immutable address');
     }
 }
+function recoverableManifestError(error) {
+    return (error instanceof ServiceError &&
+        [
+            'ARTIFACT_NOT_FOUND',
+            'ARTIFACT_MANIFEST_INVALID',
+            'ARTIFACT_MANIFEST_LIMIT',
+            'ARTIFACT_MANIFEST_INTEGRITY_FAILED',
+        ].includes(error.code));
+}
+async function enumerableArtifactManifest(workspace, directory, entryName, signal) {
+    try {
+        const manifest = await readArtifactManifest(path.join(directory, entryName), signal);
+        if (entryName !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`)
+            return undefined;
+        assertManifestAddressIntegrity(manifest, {
+            sha256: path.basename(directory),
+            provenanceHash: manifest.provenanceHash,
+            name: manifest.name,
+        });
+        return manifestBelongsToWorkspace(manifest, workspace) ? manifest : undefined;
+    }
+    catch (error) {
+        if (recoverableManifestError(error))
+            return undefined;
+        throw error;
+    }
+}
 /** Return the only artifact fields that may cross the MCP trust boundary. */
 export function publicArtifactLink(artifact) {
     return {
@@ -496,6 +531,23 @@ async function existingManifestMatches(filePath, expectedBytes, signal) {
     try {
         const manifest = await readArtifactManifest(filePath, signal);
         if (`${canonicalJson(manifest)}\n` !== expectedBytes) {
+            const expected = artifactManifestSchema.parse(JSON.parse(expectedBytes));
+            try {
+                assertManifestAddressIntegrity(manifest, {
+                    sha256: expected.sha256,
+                    provenanceHash: expected.provenanceHash,
+                    name: expected.name,
+                });
+            }
+            catch (error) {
+                if (!recoverableManifestError(error))
+                    throw error;
+                await unlink(filePath).catch((unlinkError) => {
+                    if (unlinkError.code !== 'ENOENT')
+                        throw unlinkError;
+                });
+                return false;
+            }
             throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Immutable artifact provenance manifest contains different bytes');
         }
         return true;
@@ -503,11 +555,17 @@ async function existingManifestMatches(filePath, expectedBytes, signal) {
     catch (error) {
         if (error instanceof ServiceError && error.code === 'ARTIFACT_NOT_FOUND')
             return false;
-        if (!(error instanceof ServiceError) || error.code !== 'ARTIFACT_MANIFEST_INVALID')
+        if (!(error instanceof ServiceError) ||
+            !['ARTIFACT_MANIFEST_INVALID', 'ARTIFACT_MANIFEST_LIMIT'].includes(error.code))
             throw error;
         const state = await interruptedManifestState(filePath, expectedBytes, signal);
-        if (!state.interrupted)
-            throw error;
+        if (!state.interrupted) {
+            await unlink(filePath).catch((unlinkError) => {
+                if (unlinkError.code !== 'ENOENT')
+                    throw unlinkError;
+            });
+            return false;
+        }
         try {
             await unlink(filePath);
         }
@@ -684,19 +742,31 @@ export class ArtifactStore {
                 catch (error) {
                     if (error instanceof ServiceError && error.code === 'ARTIFACT_NOT_FOUND')
                         continue;
-                    if (!(error instanceof ServiceError) || error.code !== 'ARTIFACT_MANIFEST_INVALID')
+                    if (!recoverableManifestError(error))
                         throw error;
-                    let interrupted;
                     try {
-                        interrupted = await interruptedManifestState(candidate, undefined, signal);
+                        await unlink(candidate);
                     }
-                    catch (interruptedError) {
-                        if (interruptedError instanceof ServiceError &&
-                            interruptedError.code === 'ARTIFACT_NOT_FOUND')
-                            continue;
-                        throw interruptedError;
+                    catch (unlinkError) {
+                        if (unlinkError.code !== 'ENOENT')
+                            throw unlinkError;
                     }
-                    if (!interrupted.interrupted)
+                    usage.entries = Math.max(0, usage.entries - 1);
+                    usage.bytes = Math.max(0, usage.bytes - metadata.size);
+                    continue;
+                }
+                try {
+                    if (child.name !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`) {
+                        throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest filename does not match its contents');
+                    }
+                    assertManifestAddressIntegrity(manifest, {
+                        sha256: path.basename(directory),
+                        provenanceHash: manifest.provenanceHash,
+                        name: manifest.name,
+                    });
+                }
+                catch (error) {
+                    if (!recoverableManifestError(error))
                         throw error;
                     try {
                         await unlink(candidate);
@@ -706,17 +776,9 @@ export class ArtifactStore {
                             throw unlinkError;
                     }
                     usage.entries = Math.max(0, usage.entries - 1);
-                    usage.bytes = Math.max(0, usage.bytes - interrupted.size);
+                    usage.bytes = Math.max(0, usage.bytes - metadata.size);
                     continue;
                 }
-                if (child.name !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`) {
-                    throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest filename does not match its contents');
-                }
-                assertManifestIntegrity(manifest, {
-                    sha256: path.basename(directory),
-                    provenanceHash: manifest.provenanceHash,
-                    name: manifest.name,
-                }, workspace);
                 const targetPath = await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, path.join(directory, manifest.name)));
                 let targetBytes = 0;
                 try {
@@ -728,6 +790,8 @@ export class ArtifactStore {
                 }
                 retained.push({
                     manifest,
+                    staleIdentity: manifest.workspaceIdentity !== workspace.workspaceIdentity ||
+                        manifest.ownerIdentity !== workspace.ownerIdentity,
                     manifestPath: candidate,
                     manifestBytes: metadata.size,
                     modifiedAt: metadata.mtimeMs,
@@ -789,7 +853,8 @@ export class ArtifactStore {
             }
         };
         await reclaimDebris(await containedGeneratedPath(workspace.artifactRoot));
-        retained.sort((left, right) => left.modifiedAt - right.modifiedAt ||
+        retained.sort((left, right) => Number(right.staleIdentity) - Number(left.staleIdentity) ||
+            left.modifiedAt - right.modifiedAt ||
             compareCodeUnits(left.manifestPath, right.manifestPath));
         const current = { ...usage };
         for (const candidate of retained) {
@@ -822,7 +887,7 @@ export class ArtifactStore {
                 if (error.code !== 'ENOENT')
                     throw error;
             }
-            const verificationPrefix = `${workspace.workspaceIdentity}\0${workspace.ownerIdentity}\0${candidate.targetPath}\0`;
+            const verificationPrefix = `${candidate.manifest.workspaceIdentity}\0${candidate.manifest.ownerIdentity}\0${candidate.targetPath}\0`;
             for (const key of this.#verifiedContent.keys()) {
                 if (key.startsWith(verificationPrefix))
                     this.#verifiedContent.delete(key);
@@ -859,15 +924,10 @@ export class ArtifactStore {
                     await walk(await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, candidate)));
                 }
                 else if (entry.isFile() && entry.name.endsWith('.manifest.json')) {
-                    const manifest = await readArtifactManifest(await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, candidate)), signal);
-                    if (entry.name !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`) {
-                        throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest filename does not match its contents');
-                    }
-                    assertManifestIntegrity(manifest, {
-                        sha256: path.basename(directory),
-                        provenanceHash: manifest.provenanceHash,
-                        name: manifest.name,
-                    }, workspace);
+                    await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, candidate));
+                    const manifest = await enumerableArtifactManifest(workspace, directory, entry.name, signal);
+                    if (manifest === undefined)
+                        continue;
                     results.push({
                         uri: this.uri(workspace.id, manifest.sha256, manifest.provenanceHash, manifest.name),
                         name: manifest.name,
@@ -900,15 +960,10 @@ export class ArtifactStore {
         let hasMore = false;
         const visitManifest = async (directory, entryName) => {
             signal?.throwIfAborted();
-            const manifest = await readArtifactManifest(await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, path.join(directory, entryName))), signal);
-            if (entryName !== `${manifest.name}.${manifest.provenanceHash}.manifest.json`) {
-                throw new ServiceError('ARTIFACT_MANIFEST_INTEGRITY_FAILED', 'Artifact provenance manifest filename does not match its contents');
-            }
-            assertManifestIntegrity(manifest, {
-                sha256: path.basename(directory),
-                provenanceHash: manifest.provenanceHash,
-                name: manifest.name,
-            }, workspace);
+            await containedGeneratedPath(workspace.artifactRoot, path.relative(workspace.artifactRoot, path.join(directory, entryName)));
+            const manifest = await enumerableArtifactManifest(workspace, directory, entryName, signal);
+            if (manifest === undefined)
+                return;
             const uri = this.uri(workspace.id, manifest.sha256, manifest.provenanceHash, manifest.name);
             revision.update(`${Buffer.byteLength(uri, 'utf8')}:${uri}`);
             total += 1;
@@ -981,6 +1036,20 @@ export class ArtifactStore {
             path: await containedGeneratedPath(workspace.artifactRoot, parsed.sha256.slice(0, 2), parsed.sha256, parsed.name),
         };
     }
+    async available(workspace, artifacts, signal) {
+        for (const artifact of artifacts) {
+            signal?.throwIfAborted();
+            try {
+                await this.describe(workspace, artifact.uri, signal);
+            }
+            catch (error) {
+                if (recoverableManifestError(error))
+                    return false;
+                throw error;
+            }
+        }
+        return true;
+    }
     async put(workspace, name, mimeType, content, provenance, description, signal) {
         return this.withAtomicWrites(workspace, [
             {

package/dist/hoi4_agent_tools/gui/assets.js

@@ -591,11 +591,6 @@ export class GuiAssetCatalog {
                     .ensureAlpha()
                     .raw()
                     .toBuffer({ resolveWithObject: true });
-                for (let index = 0; index < extracted.data.length; index += 4) {
-                    extracted.data[index] = 255;
-                    extracted.data[index + 1] = 255;
-                    extracted.data[index + 2] = 255;
-                }
                 const png = await sharp(extracted.data, {
                     raw: { width: extracted.info.width, height: extracted.info.height, channels: 4 },
                     limitInputPixels: RENDER_MAX_DECODED_PIXELS,

package/dist/hoi4_agent_tools/gui/layout.js

@@ -750,7 +750,10 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             displayText = `\u00a7R${rawText}_MISSING\u00a7!`;
         const fontName = scalarString(property(definition.attributes, 'font', 'buttonFont'));
         const fontDefinition = fontName === undefined ? undefined : catalog.fontDefinition(fontName);
-        const visibleText = visibleHoiText(displayText, fontDefinition?.textColours);
+        const visibleText = visibleHoiText(displayText, {
+            ...context.graph.textColours,
+            ...fontDefinition?.textColours,
+        });
         displayText = visibleText.text;
         context.work.admitText(displayText, `GUI text for ${definition.name}`);
         const resolvedFontMetrics = catalog.resolvedFontMetrics(fontName);

package/dist/hoi4_agent_tools/gui/renderer.js

@@ -63,7 +63,18 @@ function sceneGlyphDefinitions(scene) {
     ].join('');
 }
 function bitmapTintMarkup(id, colour, glyphs, rect) {
-    return `<defs><mask id="${id}" maskUnits="userSpaceOnUse" maskContentUnits="userSpaceOnUse" style="mask-type:alpha" ${rectAttributes(rect)}><g>${glyphs}</g></mask></defs><rect ${rectAttributes(rect)} fill="${colour}" mask="url(#${id})"/>`;
+    const match = /^#([0-9a-f]{6})([0-9a-f]{2})?$/iu.exec(colour);
+    const rgb = match?.[1] ?? 'ffffff';
+    const alpha = match?.[2] ?? 'ff';
+    const channels = [
+        Number.parseInt(rgb.slice(0, 2), 16) / 255,
+        Number.parseInt(rgb.slice(2, 4), 16) / 255,
+        Number.parseInt(rgb.slice(4, 6), 16) / 255,
+        Number.parseInt(alpha, 16) / 255,
+    ].map(finite);
+    const [red, green, blue, opacity] = channels;
+    const matrix = `${red} 0 0 0 0 0 ${green} 0 0 0 0 0 ${blue} 0 0 0 0 0 ${opacity} 0`;
+    return `<defs><filter id="${id}" filterUnits="userSpaceOnUse" ${rectAttributes(rect)} color-interpolation-filters="sRGB"><feColorMatrix type="matrix" values="${matrix}"/></filter></defs><g filter="url(#${id})">${glyphs}</g>`;
 }
 function actualGlyphMarkup(glyphLine, originX, baseline, horizontalScale) {
     if (glyphLine.source === 'fontkit-path')