hoi4-agent-tools 3.2.0 → 3.4.0

package/dist/hoi4_agent_tools/focus/scenario.js

@@ -0,0 +1,99 @@
+import { compareCodeUnits } from '../core/canonical.js';
+import { ServiceError } from '../core/result.js';
+function routeLockSatisfied(lock, completed) {
+    const predicates = [
+        ...lock.requiredFocusIds.map((id) => completed.has(id)),
+        ...lock.excludedFocusIds.map((id) => !completed.has(id)),
+        ...(lock.alwaysImpossible === true ? [false] : []),
+    ];
+    return lock.mode === 'any' ? predicates.some(Boolean) : predicates.every(Boolean);
+}
+/** Reports only structural evidence. Unsupported runtime triggers remain unresolved. */
+export function inspectFocusScenario(plan, completedFocusIds) {
+    const known = new Set(plan.focuses.map(({ id }) => id));
+    const completed = new Set(completedFocusIds);
+    const excludedBy = new Map();
+    for (const focus of plan.focuses)
+        for (const excluded of focus.mutuallyExclusive) {
+            const owners = excludedBy.get(excluded) ?? [];
+            owners.push(focus.id);
+            excludedBy.set(excluded, owners);
+        }
+    for (const id of completed)
+        if (!known.has(id))
+            throw new ServiceError('FOCUS_SCENARIO_UNKNOWN_FOCUS', 'Scenario names an unknown focus', {
+                treeId: plan.id,
+                focusId: id,
+            });
+    const focuses = [...plan.focuses]
+        .sort((left, right) => compareCodeUnits(left.id, right.id))
+        .map((focus) => {
+        const missingPrerequisiteGroups = focus.prerequisites.groups
+            .filter(({ focusIds }) => !focusIds.some((id) => completed.has(id)))
+            .map(({ focusIds }) => [...focusIds].sort(compareCodeUnits));
+        const blockedRouteLockIds = focus.routeLocks
+            .filter((lock) => !routeLockSatisfied(lock, completed))
+            .map(({ id }) => id)
+            .sort(compareCodeUnits);
+        const exclusiveWithCompletedIds = [
+            ...new Set([...focus.mutuallyExclusive, ...(excludedBy.get(focus.id) ?? [])]),
+        ]
+            .filter((id) => completed.has(id))
+            .sort(compareCodeUnits);
+        const unresolvedFields = [
+            ...(focus.availability === undefined ? [] : ['available']),
+            ...(focus.allowBranch === undefined ? [] : ['allow_branch']),
+            ...(focus.bypass === undefined ? [] : ['bypass']),
+            ...(focus.visibility === 'normal' ||
+                (focus.reveal?.kind === 'allow_branch' &&
+                    focus.routeLocks.some(({ field }) => field === 'allow_branch'))
+                ? []
+                : ['visibility']),
+        ];
+        const blocked = missingPrerequisiteGroups.length > 0 ||
+            blockedRouteLockIds.length > 0 ||
+            exclusiveWithCompletedIds.length > 0;
+        const status = completed.has(focus.id)
+            ? 'completed'
+            : blocked
+                ? 'blocked'
+                : unresolvedFields.length > 0
+                    ? 'unresolved'
+                    : 'structural_candidate';
+        return {
+            focusId: focus.id,
+            status,
+            missingPrerequisiteGroups,
+            blockedRouteLockIds,
+            exclusiveWithCompletedIds,
+            unresolvedFields,
+        };
+    });
+    const conflicts = new Set();
+    for (const focus of plan.focuses) {
+        if (!completed.has(focus.id))
+            continue;
+        for (const other of focus.mutuallyExclusive) {
+            if (!completed.has(other))
+                continue;
+            conflicts.add([focus.id, other].sort(compareCodeUnits).join('\0'));
+        }
+    }
+    const mutualExclusionConflicts = [...conflicts].sort(compareCodeUnits).map((pair) => {
+        const [leftFocusId, rightFocusId] = pair.split('\0');
+        return { leftFocusId: leftFocusId, rightFocusId: rightFocusId };
+    });
+    return {
+        treeId: plan.id,
+        completedFocusIds: [...completed].sort(compareCodeUnits),
+        focuses,
+        mutualExclusionConflicts,
+        counts: {
+            completed: focuses.filter(({ status }) => status === 'completed').length,
+            blocked: focuses.filter(({ status }) => status === 'blocked').length,
+            unresolved: focuses.filter(({ status }) => status === 'unresolved').length,
+            structuralCandidates: focuses.filter(({ status }) => status === 'structural_candidate')
+                .length,
+        },
+    };
+}

package/dist/hoi4_agent_tools/focus/tool-operations.js

@@ -11,6 +11,7 @@ import { setInlineFilesScanned } from '../core/operation-result.js';
 import { PACKAGE_VERSION } from '../version.js';
 import { focusPlanHash, focusPresentationEvidence, importContinuousFocusPalettes, assertCompactLayoutQuality, compactFocusTreePlanAsync, linkContinuousFocusPalettes, resolveFocusPresentation, } from './index.js';
 import { activeContinuousFocusFiles, activeFocusFiles, activeSidecar, continuousPalettes, importFocusFile, referenceCatalog, selectContinuousPlan, selectedContinuousFocusFile, selectedFocusFile, selectPlan, underConfiguredRoot, validationFromDiagnostics, } from './tool-support.js';
+import { inspectFocusScenario } from './scenario.js';
 const LARGE_FOCUS_RENDER_NODE_THRESHOLD = 200;
 const LARGE_FOCUS_RENDER_SCALE = 0.5;
 function automaticFocusRenderScale(focusCount) {
@@ -196,6 +197,9 @@ export async function prepareFocusRewrite(engine, workbench, input, context) {
             compactSourcePlan = suppliedPlan;
             compactPlanning = await compactFocusTreePlanAsync(suppliedPlan, {
                 ...(context.signal === undefined ? {} : { signal: context.signal }),
+                ...(input.compactFocusIds === undefined ? {} : { focusIds: input.compactFocusIds }),
+                ...(input.pinnedFocusIds === undefined ? {} : { pinnedFocusIds: input.pinnedFocusIds }),
+                ...(input.symmetryGroups === undefined ? {} : { symmetryGroups: input.symmetryGroups }),
             });
             plan = compactPlanning.plan;
         }
@@ -208,6 +212,9 @@ export async function prepareFocusRewrite(engine, workbench, input, context) {
         compactSourcePlan = selectPlan(imported.result, input.treeId);
         compactPlanning = await compactFocusTreePlanAsync(compactSourcePlan, {
             ...(context.signal === undefined ? {} : { signal: context.signal }),
+            ...(input.compactFocusIds === undefined ? {} : { focusIds: input.compactFocusIds }),
+            ...(input.pinnedFocusIds === undefined ? {} : { pinnedFocusIds: input.pinnedFocusIds }),
+            ...(input.symmetryGroups === undefined ? {} : { symmetryGroups: input.symmetryGroups }),
         });
         plan = compactPlanning.plan;
     }
@@ -267,7 +274,7 @@ export async function prepareFocusRewrite(engine, workbench, input, context) {
             ...(context.signal === undefined ? {} : { signal: context.signal }),
         }));
     if (input.layoutMode === 'compact')
-        assertCompactLayoutQuality(currentLayout, proposedLayout);
+        assertCompactLayoutQuality(currentLayout, proposedLayout, input.compactFocusIds !== undefined);
     const proposed = await workbench.renderAndStore(context.workspaceId, reviewPlan, {
         ...(context.principal === undefined ? {} : { principal: context.principal }),
         index: snapshot.index,
@@ -481,7 +488,14 @@ export async function inspectFocus(engine, workbench, input, context) {
             layout,
         });
         diagnostics.push(...lintDiagnostics);
-        inspectedPlans.push({ plan, layout, diagnosticCount: lintDiagnostics.length });
+        inspectedPlans.push({
+            plan,
+            layout,
+            diagnosticCount: lintDiagnostics.length,
+            ...(input.scenario === undefined
+                ? {}
+                : { scenario: inspectFocusScenario(plan, input.scenario.completedFocusIds) }),
+        });
     }
     const presentation = await resolveFocusPresentation({
         plans,
@@ -504,10 +518,11 @@ export async function inspectFocus(engine, workbench, input, context) {
         schemaVersion: 1,
         revision: snapshot.revision,
         plans,
-        layouts: inspectedPlans.map(({ plan, layout, diagnosticCount }) => ({
+        layouts: inspectedPlans.map(({ plan, layout, diagnosticCount, scenario }) => ({
             treeId: plan.id,
             layout,
             diagnosticCount,
+            ...(scenario === undefined ? {} : { scenario }),
         })),
         continuousFocusPalettes: paletteImport.palettes,
         presentation: focusPresentationEvidence(presentation),
@@ -525,7 +540,7 @@ export async function inspectFocus(engine, workbench, input, context) {
         revision: snapshot.revision,
         treeCount: plans.length,
         paletteCount: paletteImport.palettes.length,
-        trees: inspectedPlans.slice(0, 100).map(({ plan, layout, diagnosticCount }) => ({
+        trees: inspectedPlans.slice(0, 100).map(({ plan, layout, diagnosticCount, scenario }) => ({
             id: plan.id,
             sourcePath: plan.provenance.sourcePath,
             focusCount: plan.focuses.length,
@@ -539,6 +554,14 @@ export async function inspectFocus(engine, workbench, input, context) {
             layoutDecisionCount: layout.decisions.length,
             layoutMetrics: layout.metrics,
             diagnosticCount,
+            ...(scenario === undefined
+                ? {}
+                : {
+                    scenarioSummary: {
+                        ...scenario.counts,
+                        choiceConflictCount: scenario.mutualExclusionConflicts.length,
+                    },
+                }),
         })),
         palettes: [],
     });
@@ -559,6 +582,8 @@ export async function inspectFocus(engine, workbench, input, context) {
 }
 export async function renderFocus(engine, workbench, input, context, rasterize) {
     const outputName = rasterize ? 'raster' : 'render';
+    if (!rasterize && (input.cropFocusIds?.length ?? 0) > 0)
+        throw new ServiceError('FOCUS_CROP_REQUIRES_RASTER', 'Focus problem crops require focus_raster');
     await context.progress(0, 4, 'Importing and indexing focus source');
     const workspace = engine.resolver.get(context.workspaceId, context.principal);
     const snapshot = await engine.scan(context.workspaceId, { patterns: focusDomainScanPatterns(workspace) }, context.principal, context.signal);
@@ -638,6 +663,7 @@ export async function renderFocus(engine, workbench, input, context, rasterize)
         ...(input.padding === undefined ? {} : { padding: input.padding }),
         outputScale: effectiveReviewScale,
         rasterize,
+        ...(input.cropFocusIds === undefined ? {} : { cropFocusIds: input.cropFocusIds }),
         renderProfile: {
             sourceRevision: snapshot.revision,
             reviewScale: effectiveReviewScale,

package/dist/hoi4_agent_tools/gui/assets.js

@@ -8,6 +8,7 @@ import { DETERMINISTIC_TOOL_FONT_HASH, shapeFontkitOutline } from '../core/svg-t
 import { decodeDds } from './dds.js';
 import { GUI_BMFONT_MAX_CHARACTERS, GUI_BINARY_FONT_MAX_BYTES, GUI_BMFONT_MAX_BYTES, GUI_BMFONT_MAX_FIELDS_PER_RECORD, GUI_BMFONT_MAX_KERNING_PAIRS, GUI_BMFONT_MAX_PAGES, GUI_BMFONT_MAX_RECORDS, GUI_TEXT_MAX_CHARACTERS, GUI_TEXT_MAX_MISSING_GLYPH_SAMPLES, } from './limits.js';
 import { decodeTga } from './tga.js';
+import { compileGuiProgressEffect, compileGuiShaderEffect, GUI_SHADER_MAX_BYTES, } from './shader.js';
 function normalizeAssetPath(value) {
     return value
         .replaceAll('\\', '/')
@@ -157,6 +158,8 @@ export class GuiAssetCatalog {
     rasters = new Map();
     frames = new Map();
     countryFlags = new Map();
+    shaders = new Map();
+    progressShaders = new Map();
     glyphRasters = new Map();
     metrics = new Map();
     fontDefinitions = new Map();
@@ -294,11 +297,58 @@ export class GuiAssetCatalog {
     loadSecondarySpriteFrame(sprite, requestedFrame) {
         return this.loadSpriteTextureFrame(sprite, sprite.texturePath2, requestedFrame, 'secondary');
     }
+    shaderSource(sprite) {
+        if ((sprite.shaderFeatures?.length ?? 0) > 0)
+            return {
+                supported: false,
+                reason: `Shader features require additional composition: ${sprite.shaderFeatures.join(', ')}.`,
+            };
+        const reference = sprite.effectFile;
+        if (reference === undefined)
+            return { supported: false, reason: 'Sprite has no effect source.' };
+        const file = this.resolveFile(reference, sprite.sourcePath) ??
+            (/\.lua$/iu.test(reference)
+                ? this.resolveFile(reference.replace(/\.lua$/iu, '.shader'), sprite.sourcePath)
+                : undefined);
+        if (file === undefined)
+            return { supported: false, reason: `Shader source not found: ${reference}.` };
+        if (file.bytes.length > GUI_SHADER_MAX_BYTES)
+            return { supported: false, reason: 'Shader source exceeds its byte budget.' };
+        return { supported: true, file };
+    }
+    progressShader(sprite, effect) {
+        const source = this.shaderSource(sprite);
+        if (!source.supported)
+            return source;
+        const { file } = source;
+        const key = `${file.displayPath}:${file.sha256}:${effect}`;
+        let result = this.progressShaders.get(key);
+        if (result === undefined) {
+            result = compileGuiProgressEffect(file.bytes.toString('utf8'), { path: file.displayPath, sha256: file.sha256 }, effect);
+            if (this.progressShaders.size >= 1_024)
+                this.progressShaders.delete(this.progressShaders.keys().next().value);
+            this.progressShaders.set(key, result);
+        }
+        return result;
+    }
+    spriteShader(sprite, effect, uniforms) {
+        const source = this.shaderSource(sprite);
+        if (!source.supported)
+            return source;
+        const { file } = source;
+        const key = `${file.displayPath}:${file.sha256}:${effect}:${hashCanonical(uniforms)}`;
+        let result = this.shaders.get(key);
+        if (result === undefined) {
+            result = compileGuiShaderEffect(file.bytes.toString('utf8'), { path: file.displayPath, sha256: file.sha256 }, effect, uniforms);
+            // Per-render caching is bounded even with a different clock or tint for every row.
+            if (this.shaders.size >= 1_024)
+                this.shaders.delete(this.shaders.keys().next().value);
+            this.shaders.set(key, result);
+        }
+        return result;
+    }
     loadCountryFlag(tag, sprite, ideology, slotName) {
-        const normalizedTag = tag
-            .trim()
-            .replace(/[^A-Za-z0-9_]/gu, '')
-            .toUpperCase();
+        const normalizedTag = tag.trim().toUpperCase();
         const normalizedIdeology = ideology
             ?.trim()
             .replace(/[^A-Za-z0-9_]/gu, '')