hoi4-agent-tools 1.2.0 → 2.1.0

package/dist/hoi4_agent_tools/event/graph.js

@@ -451,6 +451,26 @@ function helperProjections(graph, budget) {
                 if (projectedKeys.has(projectionKey))
                     continue;
                 projectedKeys.add(projectionKey);
+                if (projected.length >= EVENT_GRAPH_MAX_HELPER_PROJECTIONS) {
+                    addIssue(graph.issues, {
+                        code: 'EVENT_HELPER_PROJECTION_LIMIT',
+                        classification: 'unresolved_analysis',
+                        severity: 'blocker',
+                        message: 'Collapsed helper projection reached its materialization ceiling; structural helper calls remain available.',
+                        confidence: 'unresolved',
+                        location: start.location,
+                        blockers: [
+                            {
+                                code: 'HELPER_PROJECTION_LIMIT',
+                                message: 'Use a bounded helper-expanded trace for paths omitted from the collapsed workspace graph.',
+                                location: start.location,
+                                details: { maximum: EVENT_GRAPH_MAX_HELPER_PROJECTIONS },
+                            },
+                        ],
+                        subjectIds: [start.from, start.to],
+                    });
+                    return stableUnique(projected);
+                }
                 projected.push({
                     id: `edge:helper-projection:${hashCanonical({
                         from: start.from,
@@ -480,9 +500,6 @@ function helperProjections(graph, budget) {
                         terminalDispatchLocation: locationKey(final.location),
                     },
                 });
-                if (projected.length > EVENT_GRAPH_MAX_HELPER_PROJECTIONS) {
-                    throw new ServiceError('EVENT_HELPER_PROJECTION_LIMIT', 'Event-chain helper expansion exceeds the fixed projection ceiling', { maximum: EVENT_GRAPH_MAX_HELPER_PROJECTIONS });
-                }
             }
         }
     }
@@ -1523,7 +1540,8 @@ export function buildEventGraph(snapshot, options = {}) {
     const fragments = analyzeFragments(snapshot, files, catalog, options, budget);
     const graph = mergeFragments(fragments);
     const partial = partialInventoryEvidence(snapshot);
-    graph.unresolved.push(...partial.unresolved);
+    for (const unresolved of partial.unresolved)
+        graph.unresolved.push(unresolved);
     assertGraphLimit(graph.nodes.length, EVENT_GRAPH_MAX_NODES, 'EVENT_NODE_LIMIT', 'node count');
     assertGraphLimit(graph.edges.length, EVENT_GRAPH_MAX_EDGES, 'EVENT_EDGE_LIMIT', 'edge count');
     assertGraphLimit(graph.stateAccesses.length, EVENT_GRAPH_MAX_STATE_ACCESSES, 'EVENT_STATE_ACCESS_LIMIT', 'state-access count');
@@ -1531,8 +1549,12 @@ export function buildEventGraph(snapshot, options = {}) {
     normalizePublicEventNodeIds(graph);
     normalizeCrossFileEdges(graph);
     ensureReferencedNodes(graph);
-    graph.edges.push(...helperProjections(graph, budget));
-    graph.stateAccesses.push(...projectHelperStateAccesses(graph, budget));
+    if (options.projectHelpers !== false) {
+        for (const edge of helperProjections(graph, budget))
+            graph.edges.push(edge);
+        for (const access of projectHelperStateAccesses(graph, budget))
+            graph.stateAccesses.push(access);
+    }
     addTerminalNodes(graph);
     graph.nodes = sortNodes(graph.nodes);
     graph.edges = stableUnique(graph.edges);

package/dist/hoi4_agent_tools/event/limits.js

@@ -1,6 +1,6 @@
 import { ServiceError } from '../core/result.js';
 export const EVENT_GRAPH_MAX_NODES = 100_000;
-export const EVENT_GRAPH_MAX_EDGES = 250_000;
+export const EVENT_GRAPH_MAX_EDGES = 500_000;
 export const EVENT_GRAPH_MAX_STATE_ACCESSES = 250_000;
 export const EVENT_GRAPH_MAX_STATE_LINKS = 250_000;
 export const EVENT_GRAPH_MAX_STATE_LINK_CANDIDATES = 500_000;

package/dist/hoi4_agent_tools/event/service.js

@@ -42,11 +42,75 @@ class BoundedEventFragmentCache {
         }
     }
 }
+function eventGraphCacheKey(workspaceId, projectHelpers) {
+    return `${workspaceId}\0${projectHelpers ? 'expanded' : 'structural'}`;
+}
 const serviceState = new WeakMap();
 const EVENT_GRAPH_ARTIFACT_MAX_BYTES = 67_108_864;
 const EVENT_GRAPH_ARTIFACT_MAX_CHUNKS = 1_024;
+const EVENT_SCAN_FULL_GRAPH_RECORD_LIMIT = 100_000;
+const EVENT_SCAN_SUMMARY_SAMPLE_LIMIT = 100;
 const SHA256_PATTERN = /^[a-f0-9]{64}$/u;
 const graphHashCache = new WeakMap();
+function groupedCounts(values, key) {
+    const counts = new Map();
+    for (const value of values) {
+        const group = key(value);
+        counts.set(group, (counts.get(group) ?? 0) + 1);
+    }
+    return Object.fromEntries([...counts].sort(([left], [right]) => compareCodeUnits(left, right)));
+}
+export function eventScanReport(graph, fullGraphRecordLimit = EVENT_SCAN_FULL_GRAPH_RECORD_LIMIT) {
+    const recordCount = graph.nodes.length +
+        graph.edges.length +
+        graph.stateAccesses.length +
+        graph.stateLinks.length +
+        graph.issues.length +
+        graph.diagnostics.length +
+        graph.unresolved.length;
+    if (recordCount <= fullGraphRecordLimit)
+        return { graph };
+    const sourceEvidence = boundedSourceHashEvidence(graph.sourceHashes);
+    return {
+        graphSummary: {
+            schemaVersion: graph.schemaVersion,
+            parserVersion: graph.parserVersion,
+            workspaceId: graph.workspaceId,
+            workspaceIdentity: graph.workspaceIdentity,
+            revision: graph.revision,
+            complete: graph.complete,
+            statistics: graph.statistics,
+            filesScanned: graph.filesScanned.length,
+            skippedSourceCount: graph.skippedSourceCount,
+            sourceHashInventory: sourceEvidence.inventory,
+            recordCounts: {
+                nodes: graph.nodes.length,
+                edges: graph.edges.length,
+                stateAccesses: graph.stateAccesses.length,
+                stateLinks: graph.stateLinks.length,
+                issues: graph.issues.length,
+                diagnostics: graph.diagnostics.length,
+                unresolved: graph.unresolved.length,
+            },
+            nodeKinds: groupedCounts(graph.nodes, ({ kind }) => kind),
+            edgeReasons: groupedCounts(graph.edges, ({ reason }) => reason),
+            issueCodes: groupedCounts(graph.issues, ({ code }) => code),
+            issueSeverities: groupedCounts(graph.issues, ({ severity }) => severity),
+            diagnosticCodes: groupedCounts(graph.diagnostics, ({ code }) => code),
+            diagnosticSeverities: groupedCounts(graph.diagnostics, ({ severity }) => severity),
+            unresolvedKinds: groupedCounts(graph.unresolved, ({ kind }) => kind),
+        },
+        issueSamples: graph.issues.slice(0, EVENT_SCAN_SUMMARY_SAMPLE_LIMIT),
+        diagnosticSamples: graph.diagnostics.slice(0, EVENT_SCAN_SUMMARY_SAMPLE_LIMIT),
+        unresolvedSamples: graph.unresolved.slice(0, EVENT_SCAN_SUMMARY_SAMPLE_LIMIT),
+        artifactProjection: {
+            mode: 'large-scan-summary',
+            fullGraphRecordCount: recordCount,
+            fullGraphRecordLimit,
+            detailQueries: ['roots', 'trace', 'explain_path', 'state_flow', 'impact'],
+        },
+    };
+}
 function cachedEventGraphHash(graph, signal) {
     signal?.throwIfAborted();
     const cached = graphHashCache.get(graph);
@@ -553,11 +617,16 @@ export class EventChainViewer {
         // principal bypass the resolver check for a later caller.
         const workspace = this.engine.resolver.get(workspaceId, options.principal);
         const generation = engineGeneration(this.engine, workspaceId);
-        const cached = this.#state.current.get(workspaceId);
+        const projectHelpers = options.projectHelpers ?? true;
+        const cacheKey = eventGraphCacheKey(workspaceId, projectHelpers);
+        const cached = this.#state.current.get(cacheKey);
         if (options.refresh !== true && cached?.generation === generation) {
             return cached.graph;
         }
-        const snapshot = await this.engine.scan(workspaceId, {}, options.principal, options.signal);
+        const sibling = this.#state.current.get(eventGraphCacheKey(workspaceId, !projectHelpers));
+        const snapshot = options.refresh !== true && sibling?.generation === generation
+            ? sibling.snapshot
+            : await this.engine.scan(workspaceId, {}, options.principal, options.signal);
         options.signal?.throwIfAborted();
         if (cached?.snapshot.revision === snapshot.revision && cached.generation === generation) {
             return cached.graph;
@@ -566,8 +635,9 @@ export class EventChainViewer {
             ...(options.signal === undefined ? {} : { signal: options.signal }),
             cache: this.#state.fragments,
             workspaceIdentity: workspace.workspaceIdentity,
+            projectHelpers,
         });
-        this.#state.current.set(workspaceId, { generation, snapshot, graph });
+        this.#state.current.set(cacheKey, { generation, snapshot, graph });
         rememberGraph(this.#state, workspaceId, graph);
         return graph;
     }
@@ -575,6 +645,7 @@ export class EventChainViewer {
         input.signal?.throwIfAborted();
         const graph = await this.scan(input.workspaceId, {
             refresh: input.refresh ?? input.mode === 'scan',
+            projectHelpers: input.mode !== 'scan' && input.mode !== 'roots',
             ...(input.principal === undefined ? {} : { principal: input.principal }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
@@ -597,7 +668,7 @@ export class EventChainViewer {
         let report;
         switch (input.mode) {
             case 'scan':
-                report = { graph };
+                report = eventScanReport(graph);
                 break;
             case 'roots':
                 report = {
@@ -662,6 +733,16 @@ export class EventChainViewer {
         }
         const graphHash = cachedEventGraphHash(graph, input.signal);
         const name = `${safeSlug(`event-${input.mode}`)}-${graph.revision.slice(0, 12)}.json`;
+        const projectedScan = input.mode === 'scan' &&
+            typeof report === 'object' &&
+            report !== null &&
+            'artifactProjection' in report;
+        const artifactSourceEvidence = projectedScan
+            ? boundedSourceHashEvidence(graph.sourceHashes)
+            : undefined;
+        const artifactUnresolved = projectedScan
+            ? graph.unresolved.slice(0, EVENT_SCAN_SUMMARY_SAMPLE_LIMIT)
+            : graph.unresolved;
         const reportJson = `${canonicalJson({
             schemaVersion: 'event-analysis.v1',
             graphSchemaVersion: graph.schemaVersion,
@@ -671,10 +752,22 @@ export class EventChainViewer {
             workspaceIdentity: graph.workspaceIdentity,
             graphRevision: graph.revision,
             graphHash,
-            sourceHashes: graph.sourceHashes,
+            sourceHashes: artifactSourceEvidence?.sourceHashes ?? graph.sourceHashes,
+            ...(artifactSourceEvidence === undefined
+                ? {}
+                : { sourceHashInventory: artifactSourceEvidence.inventory }),
             complete: graph.complete,
             filters: analysisFilters,
-            unresolved: graph.unresolved,
+            unresolved: artifactUnresolved,
+            ...(projectedScan
+                ? {
+                    unresolvedInventory: {
+                        count: graph.unresolved.length,
+                        retainedCount: artifactUnresolved.length,
+                        truncated: artifactUnresolved.length !== graph.unresolved.length,
+                    },
+                }
+                : {}),
             resources: [{ name, mimeType: 'application/json' }],
             report,
         })}\n`;
@@ -695,6 +788,7 @@ export class EventChainViewer {
     async renderAndStore(input) {
         const graph = await this.scan(input.workspaceId, {
             ...(input.refresh === undefined ? {} : { refresh: input.refresh }),
+            projectHelpers: true,
             ...(input.principal === undefined ? {} : { principal: input.principal }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
@@ -892,7 +986,7 @@ export class EventChainViewer {
         if (sources.length === 0)
             throw new ServiceError('EVENT_PROPOSED_SOURCE_REQUIRED', 'Proposed comparison source list is empty');
         assertProposedSourceBounds(sources);
-        const cached = this.#state.current.get(workspaceId);
+        const cached = this.#state.current.get(eventGraphCacheKey(workspaceId, false));
         if (cached === undefined)
             throw new ServiceError('EVENT_BASELINE_MISSING', 'Scan the workspace before comparing proposed source');
         const paths = sources.map(({ relativePath }) => validRelativeSourcePath(relativePath));
@@ -974,6 +1068,7 @@ export class EventChainViewer {
             ...(signal === undefined ? {} : { signal }),
             cache: this.#state.fragments,
             workspaceIdentity: workspace.workspaceIdentity,
+            projectHelpers: false,
         });
     }
     async #resolveGraphReference(workspaceId, reference, current, principal, signal) {
@@ -1005,6 +1100,7 @@ export class EventChainViewer {
                 input.after === undefined);
         const current = await this.scan(input.workspaceId, {
             refresh,
+            projectHelpers: false,
             ...(input.principal === undefined ? {} : { principal: input.principal }),
             ...(input.signal === undefined ? {} : { signal: input.signal }),
         });

package/dist/hoi4_agent_tools/focus/continuous-render.js

@@ -31,7 +31,9 @@ export async function renderContinuousFocusPalette(plan, diagnostics, options =
         const dataUri = iconSprite === undefined ? undefined : options.presentation?.icons[iconSprite]?.dataUri;
         return dataUri === undefined ? [] : [dataUri];
     });
-    await admitFocusIconDataUris(options, budget, renderedDataUris);
+    if (options.rasterize !== false) {
+        await admitFocusIconDataUris(options, budget, renderedDataUris);
+    }
     const columns = Math.max(1, Math.min(12, options.columns ?? 5));
     const padding = Math.max(24, options.padding ?? 64);
     const cardWidth = 190;
@@ -41,7 +43,9 @@ export async function renderContinuousFocusPalette(plan, diagnostics, options =
     const usedColumns = Math.max(1, Math.min(columns, plan.focuses.length));
     const width = padding * 2 + usedColumns * cardWidth + Math.max(0, usedColumns - 1) * gap;
     const height = padding * 2 + 84 + rows * cardHeight + Math.max(0, rows - 1) * gap;
-    budget.reserve(width, height, 'continuous focus palette PNG');
+    if (options.rasterize !== false) {
+        budget.reserve(width, height, 'continuous focus palette PNG');
+    }
     const diagnosticsById = new Map();
     const toolText = new DeterministicSvgTextRenderer();
     for (const diagnostic of diagnostics) {
@@ -120,10 +124,13 @@ export async function renderContinuousFocusPalette(plan, diagnostics, options =
     })}\n`;
     const html = `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width"><title>${escapeXml(plan.id)} continuous focus palette</title><style>html{background:#101820;color:#f3f6f8;font:14px system-ui}body{margin:0;padding:24px}.notice{color:#d7b65b}svg{max-width:100%;height:auto;border:1px solid #385064}pre{white-space:pre-wrap}</style></head><body><h1>${escapeXml(plan.id)}</h1><p class="notice">Offline source-derived review artifact &mdash; not an in-game screenshot or editor.</p>${svg}<details><summary>Structured source model</summary><pre>${escapeXml(json)}</pre></details></body></html>`;
     options.signal?.throwIfAborted();
-    assertRenderDimensions(width, height, 'continuous focus palette Sharp raster');
-    const png = await sharp(Buffer.from(svg, 'utf8'), { limitInputPixels: RENDER_MAX_PIXELS })
-        .png({ compressionLevel: 9, adaptiveFiltering: false, palette: false })
-        .toBuffer();
+    let png = Buffer.alloc(0);
+    if (options.rasterize !== false) {
+        assertRenderDimensions(width, height, 'continuous focus palette Sharp raster');
+        png = await sharp(Buffer.from(svg, 'utf8'), { limitInputPixels: RENDER_MAX_PIXELS })
+            .png({ compressionLevel: 9, adaptiveFiltering: false, palette: false })
+            .toBuffer();
+    }
     options.signal?.throwIfAborted();
     return {
         html,
@@ -133,7 +140,7 @@ export async function renderContinuousFocusPalette(plan, diagnostics, options =
         hashes: {
             html: sha256Bytes(html),
             svg: sha256Bytes(svg),
-            png: sha256Bytes(png),
+            ...(options.rasterize === false ? {} : { png: sha256Bytes(png) }),
             json: sha256Bytes(json),
         },
         sourceMap: compiled.sourceMap,
@@ -158,7 +165,9 @@ export async function storeContinuousFocusRenderArtifacts(workspace, store, plan
     const entries = [
         [`${stem}.continuous.html`, 'text/html', bundle.html, 'interactive-review'],
         [`${stem}.continuous.svg`, 'image/svg+xml', bundle.svg, 'vector-render'],
-        [`${stem}.continuous.png`, 'image/png', bundle.png, 'raster-render'],
+        ...(options.rasterize === false
+            ? []
+            : [[`${stem}.continuous.png`, 'image/png', bundle.png, 'raster-render']]),
         [`${stem}.continuous.json`, 'application/json', bundle.json, 'structured-render'],
         [
             `${stem}.continuous.source-map.json`,

package/dist/hoi4_agent_tools/focus/presentation.js

@@ -70,15 +70,34 @@ function diagnosticLocation(target) {
             : { location: target.sourceLocation }
         : { location: target.iconLocation };
 }
+async function mapWithConcurrency(values, concurrency, callback) {
+    const results = new Array(values.length);
+    let next = 0;
+    await Promise.all(Array.from({ length: Math.min(concurrency, values.length) }, async () => {
+        while (next < values.length) {
+            const index = next;
+            next += 1;
+            results[index] = await callback(values[index]);
+        }
+    }));
+    return results;
+}
 export async function resolveFocusPresentation(input) {
     input.signal?.throwIfAborted();
     const language = input.language ?? 'l_english';
     const palettes = input.palettes ?? [];
     const targets = presentationTargets(input.plans, palettes);
-    const baseGraph = buildGuiSourceGraph(input.files, input.index);
     const spriteNames = [
         ...new Set(targets.flatMap(({ sprite }) => (sprite === undefined ? [] : [sprite]))),
     ];
+    // Focus presentation needs sprite declarations, not the entire GUI, decision, and
+    // localisation graph. Localised focus text is resolved directly through the shared index.
+    const spriteSourcePaths = new Set(spriteNames.flatMap((spriteName) => {
+        const symbol = input.index.find('sprite', spriteName);
+        return symbol === undefined ? [] : [symbol.path];
+    }));
+    const presentationFiles = input.files.filter(({ displayPath }) => spriteSourcePaths.has(displayPath));
+    const baseGraph = buildGuiSourceGraph(presentationFiles, input.index);
     const texturePaths = new Set();
     for (const spriteName of spriteNames) {
         const sprite = relevantSprite(spriteName, baseGraph.sprites, input.index);
@@ -97,16 +116,17 @@ export async function resolveFocusPresentation(input) {
             ...(input.signal === undefined ? {} : { signal: input.signal }),
         });
     const combined = new Map();
-    for (const file of [...input.files, ...assets])
+    for (const file of [...presentationFiles, ...assets])
         combined.set(file.displayPath, file);
     const files = [...combined.values()].sort((left, right) => compareCodeUnits(left.displayPath, right.displayPath));
-    const graph = buildGuiSourceGraph(files, input.index.rebuild(files));
+    const graph = baseGraph;
     const catalog = new GuiAssetCatalog(graph, files, input.budget);
     const diagnostics = [];
     const entries = {};
     const icons = {};
     const sourceHashes = {};
     const relevantPaths = new Set();
+    const iconTargets = new Map();
     for (const target of targets) {
         input.signal?.throwIfAborted();
         const title = input.index.find('localisation', `${language}:${target.titleKey}`);
@@ -125,6 +145,8 @@ export async function resolveFocusPresentation(input) {
                 : { descriptionSourceLocation: description.location }),
             ...(target.sprite === undefined ? {} : { iconSprite: target.sprite }),
         };
+        if (target.sprite !== undefined && !iconTargets.has(target.sprite))
+            iconTargets.set(target.sprite, target);
         for (const [key, symbol] of [
             [target.titleKey, title],
             [target.descriptionKey, description],
@@ -147,54 +169,87 @@ export async function resolveFocusPresentation(input) {
                 details: { language, key, focusId: target.id },
             });
         }
-        if (target.sprite === undefined || icons[target.sprite] !== undefined)
-            continue;
-        const sprite = relevantSprite(target.sprite, graph.sprites, input.index);
+    }
+    const iconEntries = [...iconTargets.entries()];
+    const iconResults = await mapWithConcurrency(iconEntries, 8, async ([spriteName, target]) => {
+        const sprite = relevantSprite(spriteName, graph.sprites, input.index);
         if (sprite === undefined) {
             const partial = input.index.hasSkippedSourceForKind('sprite');
-            diagnostics.push({
-                code: partial ? 'FOCUS_ICON_REFERENCE_PARTIAL' : 'FOCUS_ICON_REFERENCE_MISSING',
-                severity: partial ? 'warning' : 'error',
-                category: 'reference',
-                message: partial
-                    ? `The partial shared inventory cannot verify sprite ${target.sprite} for focus ${target.id}`
-                    : `Focus ${target.id} references missing sprite ${target.sprite}`,
-                ...diagnosticLocation(target),
-                details: { focusId: target.id, sprite: target.sprite },
-            });
-            continue;
+            return {
+                paths: [],
+                diagnostic: {
+                    code: partial ? 'FOCUS_ICON_REFERENCE_PARTIAL' : 'FOCUS_ICON_REFERENCE_MISSING',
+                    severity: partial ? 'warning' : 'error',
+                    category: 'reference',
+                    message: partial
+                        ? `The partial shared inventory cannot verify sprite ${spriteName} for focus ${target.id}`
+                        : `Focus ${target.id} references missing sprite ${spriteName}`,
+                    ...diagnosticLocation(target),
+                    details: { focusId: target.id, sprite: spriteName },
+                },
+            };
+        }
+        const paths = [sprite.sourcePath];
+        if (input.decodeIcons === false) {
+            const texturePath = sprite.texturePath;
+            const asset = texturePath === undefined ? undefined : catalog.resolveFile(texturePath, sprite.sourcePath);
+            if (asset !== undefined)
+                return { paths: [...paths, asset.displayPath] };
+            return {
+                paths,
+                diagnostic: {
+                    code: 'FOCUS_ICON_TEXTURE_MISSING',
+                    severity: 'error',
+                    category: 'reference',
+                    message: `Focus ${target.id} cannot resolve sprite texture ${texturePath ?? '<missing>'}`,
+                    ...diagnosticLocation(target),
+                    details: { focusId: target.id, sprite: spriteName, texturePath: texturePath ?? null },
+                },
+            };
         }
-        relevantPaths.add(sprite.sourcePath);
         const frame = await catalog.loadSpriteFrame(sprite, 0);
         if (frame?.supported !== true || frame.dataUri === undefined) {
-            diagnostics.push({
-                code: 'FOCUS_ICON_TEXTURE_MISSING',
-                severity: 'error',
-                category: 'reference',
-                message: `Focus ${target.id} cannot load sprite texture ${sprite.texturePath ?? '<missing>'}: ${frame?.reason ?? 'texturefile is missing'}`,
-                ...diagnosticLocation(target),
-                details: {
-                    focusId: target.id,
-                    sprite: target.sprite,
-                    texturePath: sprite.texturePath ?? null,
+            return {
+                paths,
+                diagnostic: {
+                    code: 'FOCUS_ICON_TEXTURE_MISSING',
+                    severity: 'error',
+                    category: 'reference',
+                    message: `Focus ${target.id} cannot load sprite texture ${sprite.texturePath ?? '<missing>'}: ${frame?.reason ?? 'texturefile is missing'}`,
+                    ...diagnosticLocation(target),
+                    details: {
+                        focusId: target.id,
+                        sprite: spriteName,
+                        texturePath: sprite.texturePath ?? null,
+                    },
                 },
-            });
-            continue;
+            };
         }
         const asset = catalog.resolveFile(frame.texturePath, sprite.sourcePath);
         if (asset !== undefined)
-            relevantPaths.add(asset.displayPath);
-        icons[target.sprite] = {
-            sprite: target.sprite,
-            sourcePath: sprite.sourcePath,
-            texturePath: frame.texturePath,
-            frame: frame.frame,
-            frameCount: frame.frameCount,
-            width: frame.width,
-            height: frame.height,
-            format: frame.format,
-            dataUri: frame.dataUri,
+            paths.push(asset.displayPath);
+        return {
+            paths,
+            icon: {
+                sprite: spriteName,
+                sourcePath: sprite.sourcePath,
+                texturePath: frame.texturePath,
+                frame: frame.frame,
+                frameCount: frame.frameCount,
+                width: frame.width,
+                height: frame.height,
+                format: frame.format,
+                dataUri: frame.dataUri,
+            },
         };
+    });
+    for (const [index, result] of iconResults.entries()) {
+        for (const sourcePath of result.paths)
+            relevantPaths.add(sourcePath);
+        if (result.diagnostic !== undefined)
+            diagnostics.push(result.diagnostic);
+        if (result.icon !== undefined)
+            icons[iconEntries[index][0]] = result.icon;
     }
     for (const file of files) {
         if (relevantPaths.has(file.displayPath))

package/dist/hoi4_agent_tools/focus/render.js

@@ -168,7 +168,9 @@ function svgDocument(plan, layout, diagnostics, options) {
     const logicalHeight = Math.max(240, (maximumY - minimumY) * vertical + nodeHeight + padding * 2);
     const width = Math.max(1, Math.round(logicalWidth * outputScale));
     const height = Math.max(1, Math.round(logicalHeight * outputScale));
-    (options.budget ?? new RenderBudget()).reserve(width, height, 'focus tree PNG');
+    if (options.rasterize !== false) {
+        (options.budget ?? new RenderBudget()).reserve(width, height, 'focus tree PNG');
+    }
     const pixel = new Map(nodes.map((node) => [
         node.id,
         focusNodeOrigin(node, minimumX, minimumY, padding, horizontal, vertical),
@@ -415,18 +417,23 @@ export async function renderFocusTree(plan, layout, diagnostics, options = {}) {
         const dataUri = focusIconDataUri(focus, resolvedOptions);
         return dataUri === undefined ? [] : [dataUri];
     });
-    await admitFocusIconDataUris(resolvedOptions, budget, renderedDataUris);
+    if (options.rasterize !== false) {
+        await admitFocusIconDataUris(resolvedOptions, budget, renderedDataUris);
+    }
     const compiled = compileFocusTreeWithSourceMap(plan, layout);
     const rendered = svgDocument(plan, layout, diagnostics, resolvedOptions);
     const json = `${canonicalJson({ ...rendered.graph, generatedSourceMap: compiled.sourceMap })}\n`;
     const html = htmlDocument(plan, rendered.svg, json, diagnostics);
-    assertRenderDimensions(rendered.width, rendered.height, 'focus tree Sharp raster');
-    budget.reserveRasterOperation(`focus-tree:${sha256Bytes(rendered.svg)}`, 'focus tree SVG rasterization');
-    const png = await sharp(Buffer.from(rendered.svg, 'utf8'), {
-        limitInputPixels: RENDER_MAX_PIXELS,
-    })
-        .png({ compressionLevel: 9, adaptiveFiltering: false, palette: false })
-        .toBuffer();
+    let png = Buffer.alloc(0);
+    if (options.rasterize !== false) {
+        assertRenderDimensions(rendered.width, rendered.height, 'focus tree Sharp raster');
+        budget.reserveRasterOperation(`focus-tree:${sha256Bytes(rendered.svg)}`, 'focus tree SVG rasterization');
+        png = await sharp(Buffer.from(rendered.svg, 'utf8'), {
+            limitInputPixels: RENDER_MAX_PIXELS,
+        })
+            .png({ compressionLevel: 9, adaptiveFiltering: false, palette: false })
+            .toBuffer();
+    }
     options.signal?.throwIfAborted();
     return {
         html,
@@ -436,7 +443,7 @@ export async function renderFocusTree(plan, layout, diagnostics, options = {}) {
         hashes: {
             html: sha256Bytes(html),
             svg: sha256Bytes(rendered.svg),
-            png: sha256Bytes(png),
+            ...(options.rasterize === false ? {} : { png: sha256Bytes(png) }),
             json: sha256Bytes(json),
         },
         sourceMap: compiled.sourceMap,
@@ -478,12 +485,16 @@ export async function storeFocusRenderArtifacts(workspace, artifacts, plan, bund
             content: bundle.svg,
             provenance: { ...provenance, kind: 'focus-svg' },
         },
-        {
-            name: `${stem}.focus.png`,
-            mimeType: 'image/png',
-            content: bundle.png,
-            provenance: { ...provenance, kind: 'focus-png' },
-        },
+        ...(options.rasterize === false
+            ? []
+            : [
+                {
+                    name: `${stem}.focus.png`,
+                    mimeType: 'image/png',
+                    content: bundle.png,
+                    provenance: { ...provenance, kind: 'focus-png' },
+                },
+            ]),
         {
             name: `${stem}.focus.json`,
             mimeType: 'application/json',

package/dist/hoi4_agent_tools/gui/assets.js

@@ -219,13 +219,20 @@ export class GuiAssetCatalog {
             return Promise.resolve(undefined);
         const frameCount = Math.max(1, sprite.frameCount);
         const frame = Math.max(0, Math.min(frameCount - 1, Math.trunc(requestedFrame)));
-        const key = `${sprite.id}:${texturePath}:${frameCount}:${frame}`;
+        // Different sprite names frequently reuse the same frame strip. Cache by resolved texture and
+        // crop instead of sprite identity so large surfaces do not rasterize identical pixels hundreds
+        // of times.
+        const textureFile = this.resolveFile(texturePath, sprite.sourcePath);
+        const textureIdentity = textureFile === undefined
+            ? `${sprite.sourcePath}:${texturePath}`
+            : `${textureFile.displayPath}:${textureFile.sha256}`;
+        const key = `${textureIdentity}:${frameCount}:${frame}`;
         let promise = this.frames.get(key);
         if (promise === undefined) {
             promise = this.decodeSpriteFrame(sprite, texturePath, frameCount, frame, key);
             this.frames.set(key, promise);
         }
-        return promise;
+        return promise.then((decoded) => decoded === undefined ? undefined : { ...decoded, spriteName: sprite.name });
     }
     async decodeSpriteFrame(sprite, texturePath, frameCount, frame, operationKey) {
         const raster = await this.loadRaster(texturePath, sprite.sourcePath);