hoi4-agent-tools 3.0.0 → 3.0.2

package/dist/hoi4_agent_tools/technology/graph.js

@@ -155,7 +155,51 @@ function activeGridboxes(values) {
         .sort((left, right) => compareCodeUnits(left.folderId ?? '', right.folderId ?? '') ||
         compareCodeUnits(left.name, right.name));
 }
-function enrichPlacements(placements, edges, gridboxes, signal) {
+function activeItemLayouts(values) {
+    const groups = new Map();
+    for (const layout of values) {
+        const key = `${layout.folderId}\0${layout.layoutSize}`;
+        const group = groups.get(key) ?? [];
+        group.push(layout);
+        groups.set(key, group);
+    }
+    return [...groups.values()]
+        .map((group) => group.sort((left, right) => right.loadOrder - left.loadOrder ||
+        compareCodeUnits(left.sourcePath, right.sourcePath) ||
+        left.location.start.offset - right.location.start.offset)[0])
+        .sort((left, right) => compareCodeUnits(left.folderId, right.folderId) ||
+        compareCodeUnits(left.layoutSize, right.layoutSize));
+}
+function activeYearMarkers(values) {
+    const groups = new Map();
+    for (const marker of values) {
+        const key = `${marker.folderId}\0${marker.name}`;
+        const group = groups.get(key) ?? [];
+        group.push(marker);
+        groups.set(key, group);
+    }
+    return [...groups.values()]
+        .map((group) => group.sort((left, right) => right.loadOrder - left.loadOrder ||
+        compareCodeUnits(left.sourcePath, right.sourcePath) ||
+        left.location.start.offset - right.location.start.offset)[0])
+        .sort((left, right) => compareCodeUnits(left.folderId, right.folderId) ||
+        left.year - right.year ||
+        compareCodeUnits(left.name, right.name));
+}
+function enrichPlacements(placements, edges, gridboxes, technologies, unlocks, itemLayouts, signal) {
+    const technologyById = new Map(technologies.map((technology) => [technology.id, technology]));
+    const unlockKindsByTechnology = new Map();
+    for (const unlock of unlocks) {
+        const kinds = unlockKindsByTechnology.get(unlock.technologyId) ?? new Set();
+        kinds.add(unlock.kind);
+        unlockKindsByTechnology.set(unlock.technologyId, kinds);
+    }
+    const layoutsByFolder = new Map();
+    for (const layout of itemLayouts) {
+        const layouts = layoutsByFolder.get(layout.folderId) ?? new Map();
+        layouts.set(layout.layoutSize, layout);
+        layoutsByFolder.set(layout.folderId, layouts);
+    }
     const placementsByTechnology = new Map();
     for (const placement of placements) {
         const group = placementsByTechnology.get(placement.technologyId) ?? [];
@@ -198,6 +242,15 @@ function enrichPlacements(placements, edges, gridboxes, signal) {
             : gridboxes.filter(({ name, folderId }) => name === expectedGridbox &&
                 (folderId === undefined || folderId === placement.folderId));
         const gridbox = candidates[0];
+        const technology = technologyById.get(placement.technologyId);
+        const folderLayouts = layoutsByFolder.get(placement.folderId);
+        const unlockKinds = unlockKindsByTechnology.get(placement.technologyId) ?? new Set();
+        const unlocksEquipment = unlockKinds.has('equipment') || unlockKinds.has('equipment_module');
+        const layoutSize = technology?.layoutSize === 'small' ||
+            (folderLayouts?.has('small') === true && !unlocksEquipment)
+            ? 'small'
+            : 'large';
+        const itemLayout = folderLayouts?.get(layoutSize) ?? folderLayouts?.get('large');
         let pixelX;
         let pixelY;
         if (gridbox !== undefined &&
@@ -223,6 +276,12 @@ function enrichPlacements(placements, edges, gridboxes, signal) {
             ...(gridbox === undefined ? {} : { gridboxId: gridbox.id }),
             ...(pixelX === undefined ? {} : { pixelX }),
             ...(pixelY === undefined ? {} : { pixelY }),
+            layoutSize,
+            ...(itemLayout === undefined ? {} : { itemLayoutId: itemLayout.id }),
+            ...(itemLayout?.size.width === undefined ? {} : { layoutWidth: itemLayout.size.width }),
+            ...(itemLayout?.size.height === undefined ? {} : { layoutHeight: itemLayout.size.height }),
+            ...(itemLayout?.position.x === undefined ? {} : { layoutOffsetX: itemLayout.position.x }),
+            ...(itemLayout?.position.y === undefined ? {} : { layoutOffsetY: itemLayout.position.y }),
             geometryStatus: pixelX !== undefined && pixelY !== undefined
                 ? 'source_pixel'
                 : placement.x !== undefined && placement.y !== undefined
@@ -1093,6 +1152,8 @@ export function buildTechnologyGraph(snapshot, options) {
     const selectedFolders = activeDefinitions(fragments.flatMap(({ folders }) => folders));
     const folders = localiseFolders(selectedFolders.active, snapshot.index);
     const gridboxes = activeGridboxes(fragments.flatMap(({ gridboxes }) => gridboxes));
+    const itemLayouts = activeItemLayouts(fragments.flatMap(({ itemLayouts }) => itemLayouts));
+    const yearMarkers = activeYearMarkers(fragments.flatMap(({ yearMarkers }) => yearMarkers));
     const categories = activeCategories(fragments.flatMap(({ categories }) => categories));
     const selectedDoctrines = activeDefinitions(fragments.flatMap(({ doctrineDefinitions }) => doctrineDefinitions));
     const doctrineDefinitions = localiseDoctrines(selectedDoctrines.active, snapshot.index, assets);
@@ -1102,8 +1163,8 @@ export function buildTechnologyGraph(snapshot, options) {
     const unlockTargets = selectedTargets.active;
     const basePlacements = selectOwnedRecords(fragments.flatMap(({ placements }) => placements), ({ technologyId }) => technologyId, ({ location }) => location, technologyById).sort((left, right) => compareCodeUnits(left.id, right.id));
     const edges = selectOwnedRecords(fragments.flatMap(({ edges }) => edges), ({ from }) => from, ({ location }) => location, technologyById).sort((left, right) => compareCodeUnits(left.id, right.id));
-    const placements = enrichPlacements(basePlacements, edges, gridboxes, options.signal);
     const unlocks = resolveUnlocks(selectOwnedRecords(fragments.flatMap(({ unlocks }) => unlocks), ({ technologyId }) => technologyId, ({ location }) => location, technologyById).sort((left, right) => compareCodeUnits(left.id, right.id)), unlockTargets, snapshot.complete);
+    const placements = enrichPlacements(basePlacements, edges, gridboxes, technologies, unlocks, itemLayouts, options.signal);
     const unresolved = fragments.flatMap(({ unresolved }) => unresolved);
     const helperCalls = fragments.flatMap(({ helperCalls }) => helperCalls);
     const externalReferences = expandHelperReferences(fragments.flatMap(({ externalReferences }) => externalReferences), helperCalls, unresolved, options.analysisMode ?? 'full', options.signal);
@@ -1167,6 +1228,8 @@ export function buildTechnologyGraph(snapshot, options) {
         folders,
         placements,
         gridboxes,
+        itemLayouts,
+        yearMarkers,
         edges,
         categories,
         doctrineDefinitions,
@@ -1183,6 +1246,8 @@ export function buildTechnologyGraph(snapshot, options) {
             folderCount: folders.length,
             placementCount: placements.length,
             gridboxCount: gridboxes.length,
+            itemLayoutCount: itemLayouts.length,
+            yearMarkerCount: yearMarkers.length,
             prerequisiteCount: edges.filter(({ kind }) => kind === 'prerequisite').length,
             exclusiveCount: edges.filter(({ kind }) => kind === 'exclusive').length,
             categoryCount: categories.length,

package/dist/hoi4_agent_tools/technology/model.js

@@ -1,2 +1,2 @@
-export const TECHNOLOGY_GRAPH_SCHEMA_VERSION = 1;
+export const TECHNOLOGY_GRAPH_SCHEMA_VERSION = 2;
 export const TECHNOLOGY_PARSER_VERSION = 'clausewitz-cst.v1';

package/dist/hoi4_agent_tools/technology/queries.js

@@ -15,6 +15,8 @@ function technologyRecordCount(graph) {
         graph.categories.length +
         graph.placements.length +
         graph.gridboxes.length +
+        graph.itemLayouts.length +
+        graph.yearMarkers.length +
         graph.edges.length +
         graph.unlocks.length +
         graph.unlockTargets.length +
@@ -62,6 +64,8 @@ export function technologyScanReport(graph, fullGraphRecordLimit = TECHNOLOGY_SC
             categories: graph.categories.length,
             placements: graph.placements.length,
             gridboxes: graph.gridboxes.length,
+            itemLayouts: graph.itemLayouts.length,
+            yearMarkers: graph.yearMarkers.length,
             edges: graph.edges.length,
             unlocks: graph.unlocks.length,
             unlockTargets: graph.unlockTargets.length,

package/dist/hoi4_agent_tools/technology/render.js

@@ -46,7 +46,7 @@ function technologyNode(graph, technologyId, placement) {
         kind: technology.kind,
         sourcePath: technology.source.path,
         sourceLine: technology.source.location.start.line,
-        layoutSize: technology.layoutSize,
+        layoutSize: placement?.layoutSize ?? technology.layoutSize,
         iconSprite: technology.icon.sprite,
         ...(placement === undefined ? {} : { placement }),
     };
@@ -61,6 +61,7 @@ function sortedUniqueNodes(values) {
 function viewSelection(graph, options) {
     const nodes = [];
     const edges = [];
+    let yearMarkers = [];
     let title;
     let sourceAccurate = false;
     if (options.view === 'summary') {
@@ -117,6 +118,7 @@ function viewSelection(graph, options) {
             .filter(({ from, to }) => selected.has(from) && selected.has(to))
             .map(({ id, from, to, kind }) => ({ id, from, to, kind })));
         sourceAccurate = true;
+        yearMarkers = graph.yearMarkers.filter(({ folderId }) => folderId === options.folderId);
     }
     else if (options.view === 'dependencies' || options.view === 'technology') {
         const ids = options.technologyId === undefined
@@ -407,6 +409,7 @@ function viewSelection(graph, options) {
     return {
         nodes: selectedNodes,
         edges: selectedEdges,
+        yearMarkers,
         sourceAccurate,
         title,
         payload: {
@@ -416,6 +419,7 @@ function viewSelection(graph, options) {
             generatedAnalysisLayout: !sourceAccurate,
             nodes: selectedNodes,
             edges: selectedEdges,
+            yearMarkers,
             graphRevision: graph.revision,
             analysisBoundary: graph.analysisBoundary,
         },
@@ -424,38 +428,61 @@ function viewSelection(graph, options) {
 function issueKey(issue) {
     return sha256Bytes(canonicalJson({ code: issue.code, details: issue.details })).slice(0, 20);
 }
-function layoutFolder(nodes) {
-    const dimensions = (node) => node.layoutSize === 'small'
-        ? { width: SMALL_NODE_WIDTH, height: SMALL_NODE_HEIGHT }
-        : { width: LARGE_NODE_WIDTH, height: LARGE_NODE_HEIGHT };
+function layoutFolder(nodes, yearMarkers) {
+    const dimensions = (node) => node.placement?.layoutWidth !== undefined && node.placement.layoutHeight !== undefined
+        ? { width: node.placement.layoutWidth, height: node.placement.layoutHeight }
+        : node.layoutSize === 'small'
+            ? { width: SMALL_NODE_WIDTH, height: SMALL_NODE_HEIGHT }
+            : { width: LARGE_NODE_WIDTH, height: LARGE_NODE_HEIGHT };
     const sourcePixel = nodes.filter(({ placement }) => placement?.pixelX !== undefined && placement.pixelY !== undefined);
     if (sourcePixel.length === nodes.length && sourcePixel.length > 0) {
-        const minimumX = Math.min(...sourcePixel.map(({ placement }) => placement.pixelX));
-        const minimumY = Math.min(...sourcePixel.map(({ placement }) => placement.pixelY));
-        return sourcePixel.map((node) => {
+        const sourceNodeX = (node) => node.placement.pixelX + (node.placement?.layoutOffsetX ?? 0);
+        const sourceNodeY = (node) => node.placement.pixelY + (node.placement?.layoutOffsetY ?? 0);
+        const minimumX = Math.min(...sourcePixel.map(sourceNodeX), ...yearMarkers.map(({ position }) => position.x));
+        const minimumY = Math.min(...sourcePixel.map(sourceNodeY), ...yearMarkers.map(({ position }) => position.y));
+        const positionedNodes = sourcePixel.map((node) => {
             const size = dimensions(node);
             return {
                 ...node,
-                x: PADDING + node.placement.pixelX - minimumX,
-                y: HEADER_HEIGHT + PADDING + node.placement.pixelY - minimumY,
+                x: PADDING + sourceNodeX(node) - minimumX,
+                y: HEADER_HEIGHT + PADDING + sourceNodeY(node) - minimumY,
                 ...size,
             };
         });
+        const positionedYearMarkers = yearMarkers.map((marker) => ({
+            ...marker,
+            x: PADDING + marker.position.x - minimumX,
+            y: HEADER_HEIGHT + PADDING + marker.position.y - minimumY,
+        }));
+        const xValues = yearMarkers.map(({ position }) => position.x);
+        const yValues = yearMarkers.map(({ position }) => position.y);
+        const xSpan = xValues.length === 0 ? 0 : Math.max(...xValues) - Math.min(...xValues);
+        const ySpan = yValues.length === 0 ? 0 : Math.max(...yValues) - Math.min(...yValues);
+        return {
+            nodes: positionedNodes,
+            yearMarkers: positionedYearMarkers,
+            ...(yearMarkers.length === 0
+                ? {}
+                : { yearAxis: xSpan >= ySpan ? 'horizontal' : 'vertical' }),
+        };
     }
     const branchRoots = [
         ...new Set(nodes.map(({ placement }) => placement?.branchRootId ?? '<unresolved>')),
     ].sort(compareCodeUnits);
     const lanes = new Map(branchRoots.map((id, index) => [id, index]));
-    return nodes.map((node, index) => {
-        const placement = node.placement;
-        const lane = lanes.get(placement?.branchRootId ?? '<unresolved>') ?? 0;
-        const size = dimensions(node);
-        const x = PADDING + lane * 680 + (placement?.x ?? index % 3) * (LARGE_NODE_WIDTH + GAP_X);
-        const y = HEADER_HEIGHT +
-            PADDING +
-            (placement?.y ?? Math.floor(index / 3)) * (LARGE_NODE_HEIGHT + GAP_Y);
-        return { ...node, x, y, ...size };
-    });
+    return {
+        nodes: nodes.map((node, index) => {
+            const placement = node.placement;
+            const lane = lanes.get(placement?.branchRootId ?? '<unresolved>') ?? 0;
+            const size = dimensions(node);
+            const x = PADDING + lane * 680 + (placement?.x ?? index % 3) * (LARGE_NODE_WIDTH + GAP_X);
+            const y = HEADER_HEIGHT +
+                PADDING +
+                (placement?.y ?? Math.floor(index / 3)) * (LARGE_NODE_HEIGHT + GAP_Y);
+            return { ...node, x, y, ...size };
+        }),
+        yearMarkers: [],
+    };
 }
 function layoutGenerated(nodes, edges) {
     const ids = new Set(nodes.map(({ id }) => id));
@@ -544,9 +571,9 @@ function colours(kind) {
         removed: { fill: '#4a2828', stroke: '#ef7d7d' },
     }[kind];
 }
-function svgFor(titleText, positioned, edges, sourceAccurate, iconDataUris) {
-    const maximumX = Math.max(PADDING + LARGE_NODE_WIDTH, ...positioned.map(({ x, width }) => x + width));
-    const maximumY = Math.max(HEADER_HEIGHT + LARGE_NODE_HEIGHT, ...positioned.map(({ y, height }) => y + height));
+function svgFor(titleText, positioned, edges, sourceAccurate, iconDataUris, yearMarkers, yearAxis) {
+    const maximumX = Math.max(PADDING + LARGE_NODE_WIDTH, ...positioned.map(({ x, width }) => x + width), ...yearMarkers.map(({ x }) => x + 70));
+    const maximumY = Math.max(HEADER_HEIGHT + LARGE_NODE_HEIGHT, ...positioned.map(({ y, height }) => y + height), ...yearMarkers.map(({ y }) => y + 30));
     const width = Math.ceil(maximumX + PADDING);
     const height = Math.ceil(maximumY + PADDING);
     if (width > 16_384 || height > 16_384 || width * height > RENDER_MAX_PIXELS)
@@ -556,6 +583,19 @@ function svgFor(titleText, positioned, edges, sourceAccurate, iconDataUris) {
         });
     const byId = new Map(positioned.map((node) => [node.id, node]));
     const text = new DeterministicSvgTextRenderer();
+    const yearGuideSvg = yearMarkers.map((marker) => {
+        const guide = yearAxis === 'vertical'
+            ? `<line x1="${PADDING}" y1="${marker.y + 15}" x2="${width - PADDING}" y2="${marker.y + 15}" stroke="#34495c" stroke-width="1" stroke-dasharray="5 7"/>`
+            : `<line x1="${marker.x + 24}" y1="${HEADER_HEIGHT}" x2="${marker.x + 24}" y2="${height - PADDING}" stroke="#34495c" stroke-width="1" stroke-dasharray="5 7"/>`;
+        const label = text.render(String(marker.year), {
+            x: marker.x,
+            y: marker.y + 22,
+            fontSize: 18,
+            fill: '#c7d4df',
+            weight: 700,
+        });
+        return `<g data-tech-year="${marker.year}" data-year-axis="${yearAxis ?? 'horizontal'}" data-source-path="${escapeXml(marker.sourcePath)}" data-source-line="${marker.location.start.line}">${guide}${label}</g>`;
+    });
     const edgeSvg = edges.flatMap((edge) => {
         const from = byId.get(edge.from);
         const to = byId.get(edge.to);
@@ -624,7 +664,7 @@ function svgFor(titleText, positioned, edges, sourceAccurate, iconDataUris) {
     return {
         width,
         height,
-        svg: `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-label="${escapeXml(titleText)}"><defs><marker id="tech-arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M 0 0 L 10 5 L 0 10 z" fill="#8298ad"/></marker>${text.definitions()}</defs><rect width="100%" height="100%" fill="#0d1721"/>${title}${mode}<g>${edgeSvg.join('')}</g><g>${nodeSvg.join('')}</g></svg>`,
+        svg: `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" role="img" aria-label="${escapeXml(titleText)}"><defs><marker id="tech-arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="6" markerHeight="6" orient="auto-start-reverse"><path d="M 0 0 L 10 5 L 0 10 z" fill="#8298ad"/></marker>${text.definitions()}</defs><rect width="100%" height="100%" fill="#0d1721"/>${title}${mode}<g>${yearGuideSvg.join('')}</g><g>${edgeSvg.join('')}</g><g>${nodeSvg.join('')}</g></svg>`,
     };
 }
 function htmlFor(title, svg, json) {
@@ -637,16 +677,17 @@ export async function renderTechnologyGraph(graph, options) {
     const retained = selection.nodes.slice(0, maximum);
     const retainedIds = new Set(retained.map(({ id }) => id));
     const edges = selection.edges.filter(({ from, to }) => retainedIds.has(from) && retainedIds.has(to));
-    const positioned = selection.sourceAccurate
-        ? layoutFolder(retained)
-        : layoutGenerated(retained, edges);
+    const folderLayout = selection.sourceAccurate
+        ? layoutFolder(retained, selection.yearMarkers)
+        : { nodes: layoutGenerated(retained, edges), yearMarkers: [] };
+    const positioned = folderLayout.nodes;
     const iconDataUris = options.iconDataUris ?? {};
     const requestedIconSprites = [
         ...new Set(retained.flatMap(({ iconSprite }) => (iconSprite === undefined ? [] : [iconSprite]))),
     ].sort(compareCodeUnits);
     const renderedIconSprites = requestedIconSprites.filter((sprite) => iconDataUris[sprite] !== undefined);
     const unresolvedIconSprites = requestedIconSprites.filter((sprite) => iconDataUris[sprite] === undefined);
-    const rendered = svgFor(selection.title, positioned, edges, selection.sourceAccurate, iconDataUris);
+    const rendered = svgFor(selection.title, positioned, edges, selection.sourceAccurate, iconDataUris, folderLayout.yearMarkers, folderLayout.yearAxis);
     const budget = options.budget ?? new RenderBudget();
     budget.reserve(rendered.width, rendered.height, `technology ${options.view} render`);
     budget.reserveRasterOperation(`technology-render:${graph.revision}:${options.view}:${sha256Bytes(rendered.svg)}`, `technology ${options.view} rasterization`);
@@ -667,6 +708,10 @@ export async function renderTechnologyGraph(graph, options) {
             unresolvedSprites: unresolvedIconSprites,
         },
         render: { width: rendered.width, height: rendered.height },
+        yearGuide: {
+            axis: folderLayout.yearAxis ?? null,
+            markerCount: folderLayout.yearMarkers.length,
+        },
     })}\n`;
     const html = options.includeHtml === true ? htmlFor(selection.title, rendered.svg, json) : undefined;
     return {

package/dist/hoi4_agent_tools/technology/service.js

@@ -10,6 +10,7 @@ import { GuiAssetCatalog } from '../gui/assets.js';
 import { buildGuiSourceGraph } from '../gui/source-graph.js';
 import { compareTechnologyGraphs } from './compare.js';
 import { buildTechnologyGraph, technologyAssetPatterns } from './graph.js';
+import { TECHNOLOGY_GRAPH_SCHEMA_VERSION } from './model.js';
 import { analyzeTechnologyImpact, discoverTechnologyFolders, explainTechnology, inspectTechnologyUnlocks, lintTechnologyGraph, technologyBonusCoverage, technologyScanReport, traceTechnology, } from './queries.js';
 import { renderTechnologyGraph, technologyRenderIconSprites, } from './render.js';
 const FRAGMENT_CACHE_ENTRIES = 8_192;
@@ -293,13 +294,15 @@ function validateGraph(value) {
         throw new ServiceError('TECH_GRAPH_ARTIFACT_INVALID', 'Technology graph artifact is not an object');
     const graph = value;
     const sourceHashes = value.sourceHashes;
-    if (graph.schemaVersion !== 1 ||
+    if (graph.schemaVersion !== TECHNOLOGY_GRAPH_SCHEMA_VERSION ||
         typeof graph.workspaceId !== 'string' ||
         typeof graph.workspaceIdentity !== 'string' ||
         typeof graph.revision !== 'string' ||
         !Array.isArray(graph.technologies) ||
         !Array.isArray(graph.edges) ||
         !Array.isArray(graph.placements) ||
+        !Array.isArray(graph.itemLayouts) ||
+        !Array.isArray(graph.yearMarkers) ||
         sourceHashes === null ||
         typeof sourceHashes !== 'object')
         throw new ServiceError('TECH_GRAPH_ARTIFACT_INVALID', 'Technology graph artifact has an invalid schema');

package/dist/hoi4_agent_tools/technology/source-analysis.js

@@ -350,11 +350,7 @@ function parseTechnologyDefinitions(file, document, fragment) {
             ].sort(compareCodeUnits);
             const layoutExpression = firstValue(block, 'force_use_small_tech_layout');
             const smallLayout = booleanValue(layoutExpression);
-            const layoutSize = layoutExpression === undefined || smallLayout === false
-                ? 'large'
-                : smallLayout === true
-                    ? 'small'
-                    : 'unknown';
+            const layoutSize = smallLayout === true ? 'small' : 'unknown';
             const unsupportedFields = fragment.placements
                 .filter(({ technologyId, xExpression, yExpression }) => technologyId === id && (xExpression !== undefined || yExpression !== undefined))
                 .map((placement) => ({
@@ -581,12 +577,22 @@ function parseModernDoctrines(file, document, fragment) {
         }
     }
 }
+function technologyFolderContainer(namedContainers) {
+    return [...namedContainers].reverse().find((name) => /_folder(?:_|$)/iu.test(name));
+}
+function technologyItemLayoutName(name) {
+    const small = /^techtree_(.+)_small_item$/iu.exec(name);
+    if (small?.[1] !== undefined)
+        return { folderId: small[1], layoutSize: 'small' };
+    const large = /^techtree_(.+)_item$/iu.exec(name);
+    if (large?.[1] !== undefined)
+        return { folderId: large[1], layoutSize: 'large' };
+    return undefined;
+}
 function parseTechnologyGridboxes(file, document, fragment, signal) {
     if (!normalizedPath(file).endsWith('.gui'))
         return;
-    const stack = [
-        { block: document.root, namedContainers: [] },
-    ];
+    const stack = [{ block: document.root, namedContainers: [], offsetX: 0, offsetY: 0 }];
     let visited = 0;
     while (stack.length > 0) {
         if (visited % 128 === 0)
@@ -599,11 +605,14 @@ function parseTechnologyGridboxes(file, document, fragment, signal) {
             const block = assignment.value;
             const elementType = assignment.key.value.toLowerCase();
             const name = firstScalar(block, 'name');
+            const position = childBlocks(block, 'position')[0];
+            const localX = numericLiteral(position === undefined ? undefined : firstValue(position, 'x'));
+            const localY = numericLiteral(position === undefined ? undefined : firstValue(position, 'y'));
+            const absoluteX = current.offsetX + (localX ?? 0);
+            const absoluteY = current.offsetY + (localY ?? 0);
+            const folderId = technologyFolderContainer(current.namedContainers);
             if (elementType === 'gridboxtype' && name?.value.endsWith('_tree') === true) {
-                const position = childBlocks(block, 'position')[0];
                 const slotSize = childBlocks(block, 'slotsize')[0];
-                const x = numericLiteral(position === undefined ? undefined : firstValue(position, 'x'));
-                const y = numericLiteral(position === undefined ? undefined : firstValue(position, 'y'));
                 const width = numericLiteral(slotSize === undefined ? undefined : firstValue(slotSize, 'width'));
                 const height = numericLiteral(slotSize === undefined ? undefined : firstValue(slotSize, 'height'));
                 const gridbox = {
@@ -613,16 +622,14 @@ function parseTechnologyGridboxes(file, document, fragment, signal) {
                         offset: assignment.start,
                     }),
                     name: name.value,
-                    ...(current.namedContainers.at(-1) === undefined
-                        ? {}
-                        : { folderId: current.namedContainers.at(-1) }),
+                    ...(folderId === undefined ? {} : { folderId }),
                     position: {
-                        ...(x === undefined ? {} : { x }),
-                        ...(y === undefined ? {} : { y }),
-                        ...(position === undefined || x !== undefined
+                        ...(localX === undefined ? {} : { x: absoluteX }),
+                        ...(localY === undefined ? {} : { y: absoluteY }),
+                        ...(position === undefined || localX !== undefined
                             ? {}
                             : { xExpression: firstValue(position, 'x') ?? '<missing>' }),
-                        ...(position === undefined || y !== undefined
+                        ...(position === undefined || localY !== undefined
                             ? {}
                             : { yExpression: firstValue(position, 'y') ?? '<missing>' }),
                     },
@@ -645,11 +652,85 @@ function parseTechnologyGridboxes(file, document, fragment, signal) {
                 };
                 fragment.gridboxes.push(gridbox);
             }
+            if (elementType === 'containerwindowtype' && name !== undefined) {
+                const item = technologyItemLayoutName(name.value);
+                if (item !== undefined) {
+                    const size = childBlocks(block, 'size')[0];
+                    const width = numericLiteral(size === undefined ? undefined : firstValue(size, 'width'));
+                    const height = numericLiteral(size === undefined ? undefined : firstValue(size, 'height'));
+                    const layout = {
+                        id: deterministicId('tech-item-layout', {
+                            name: name.value,
+                            path: file.displayPath,
+                            offset: assignment.start,
+                        }),
+                        name: name.value,
+                        folderId: item.folderId,
+                        layoutSize: item.layoutSize,
+                        position: {
+                            ...(localX === undefined ? {} : { x: localX }),
+                            ...(localY === undefined ? {} : { y: localY }),
+                            ...(position === undefined || localX !== undefined
+                                ? {}
+                                : { xExpression: firstValue(position, 'x') ?? '<missing>' }),
+                            ...(position === undefined || localY !== undefined
+                                ? {}
+                                : { yExpression: firstValue(position, 'y') ?? '<missing>' }),
+                        },
+                        size: {
+                            ...(width === undefined ? {} : { width }),
+                            ...(height === undefined ? {} : { height }),
+                            ...(size === undefined || width !== undefined
+                                ? {}
+                                : { widthExpression: firstValue(size, 'width') ?? '<missing>' }),
+                            ...(size === undefined || height !== undefined
+                                ? {}
+                                : { heightExpression: firstValue(size, 'height') ?? '<missing>' }),
+                        },
+                        location: nodeLocation(document, assignment, name.value),
+                        sourcePath: file.displayPath,
+                        loadOrder: file.loadOrder,
+                    };
+                    fragment.itemLayouts.push(layout);
+                }
+            }
+            if (elementType === 'instanttextboxtype' && name !== undefined && folderId !== undefined) {
+                const text = firstValue(block, 'text');
+                const year = text === undefined
+                    ? undefined
+                    : /^(?:18|19|20)\d{2}$/u.test(text)
+                        ? Number(text)
+                        : undefined;
+                if (year !== undefined && localX !== undefined && localY !== undefined) {
+                    const marker = {
+                        id: deterministicId('tech-year-marker', {
+                            name: name.value,
+                            year,
+                            path: file.displayPath,
+                            offset: assignment.start,
+                        }),
+                        name: name.value,
+                        folderId,
+                        year,
+                        position: { x: absoluteX, y: absoluteY },
+                        location: nodeLocation(document, assignment, name.value),
+                        sourcePath: file.displayPath,
+                        loadOrder: file.loadOrder,
+                    };
+                    fragment.yearMarkers.push(marker);
+                }
+            }
             const namedContainers = name !== undefined &&
                 (elementType === 'containerwindowtype' || elementType === 'windowtype')
                 ? [...current.namedContainers, name.value]
                 : current.namedContainers;
-            stack.push({ block, namedContainers });
+            const positionedContainer = elementType === 'containerwindowtype' || elementType === 'windowtype';
+            stack.push({
+                block,
+                namedContainers,
+                offsetX: positionedContainer ? absoluteX : current.offsetX,
+                offsetY: positionedContainer ? absoluteY : current.offsetY,
+            });
         }
     }
 }
@@ -913,6 +994,8 @@ export function analyzeTechnologySource(file, context) {
         folders: [],
         placements: [],
         gridboxes: [],
+        itemLayouts: [],
+        yearMarkers: [],
         edges: [],
         categories: [],
         doctrineDefinitions: [],

package/dist/hoi4_agent_tools/version.js

@@ -1,6 +1,6 @@
 import { LATEST_PROTOCOL_VERSION } from '@modelcontextprotocol/sdk/types.js';
 export const PACKAGE_NAME = 'hoi4-agent-tools';
-export const PACKAGE_VERSION = '3.0.0';
+export const PACKAGE_VERSION = '3.0.2';
 export const MCP_PROTOCOL_VERSION = LATEST_PROTOCOL_VERSION;
 export const CONFIG_VERSION = 1;
 export const TRANSACTION_VERSION = 1;

package/docs/gui.md

@@ -35,6 +35,8 @@ The renderer resolves sprites and fonts through the complete mod, dependency, an
 
 Bitmap text uses the language-appropriate HOI4 font definition and its real glyph atlas. Header, serif, compact, typewriter, black, inverted, and other declared faces keep their own glyph shapes, native metrics, face colour, border colour, language override, and font-specific `textcolors` palette. The renderer reads BMFont channel roles, separates face and outline coverage, and recognizes both vanilla black-on-white masks and conventional white-on-transparent custom masks. HOI4 localisation colour runs such as `§Y` and `§R` therefore colour the glyph face while retaining its sharp antialiasing and declared border instead of flattening the glyph into a blurred monochrome mask or switching to the tool font. The default language uses the base font rather than an unrelated language override, and the renderer recognizes installed-game atlases whose filename omits a page suffix declared by the matching `.fnt` file.
 
+`uiScale` is the in-game UI scale, not an image zoom. Use `1` for the normal 1920×1080 layout. Enlarged bitmap-font glyphs are pre-scaled from their real atlas with deterministic pixel sampling, and bitmap colours use alpha masks so local and VPS renders produce the same pixels.
+
 Layout follows Clausewitz orientation and element-origin anchors, including `CENTER_LEFT`, `CENTER_RIGHT`, `CENTER_UP`, `CENTER_DOWN`, `origo`, `centerposition`, inherited container coordinate origins, local scale, and both `%` and `%%` relative dimensions. Text boxes use native font metrics together with `maxWidth`, `maxHeight`, alignment, wrapping, and `fixedsize` clipping. Cornered tile sprites use fixed nine-slice borders and optional center tiling; progress bars composite their filled and background textures; masked shields composite their background and mask textures.
 
 Scripted-GUI composition follows `parent_scripted_gui` chains even when the linked child window is a top-level sibling in the `.gui` file. Literal `always = yes` and `always = no` visibility and click-enabled blocks are applied automatically. A scenario's `values` object supplies concrete runtime values in one place: variable names resolve numeric text, scripted-localisation names resolve dynamic labels, a progress-bar element name sets its fill value, and element keys ending in `.image`, `.frame`, `.x`, `.y`, `.visible`, or `.enabled` update that visual property. Scripted-GUI property expressions such as `image = "[GetMeterSprite]"` or `x = meter_fill_width` consume matching scenario values automatically. Dynamic text is parsed after scenario and scripted-localisation substitution, so a runtime string containing `£command_power` or `£[GetResourceIcon]` renders the resolved inline HOI4 text icon instead of literal marker text. Dynamic lists instantiate their declared `entry_container` or `country_scope_entry_container`; each scenario row can select the country template with `countryScope`, choose an explicit `entryContainer`, provide `countryTag` and `ideology` for `GetFlag`, and supply row-scoped text, image, frame, position, visibility, and enabled values. Masked country sprites use the actual mask and overlay dimensions, so custom flag sizes are discovered from GFX assets rather than assumed by the renderer.

package/docs/probability.md

@@ -16,7 +16,9 @@ Use them for event timing and option weights, decision and mission scores, focus
 
 All seven tools are read-only. Proposed source is parsed in memory and never written. When an installed game root is configured, evaluation fails closed unless `launcher-settings.json` identifies the supported HOI4 build and checksum. Results otherwise state that they target the adapter version without claiming local-game verification.
 
-Pass a source without an adapter when the surface type is not yet known. Inspection returns every compatible adapter, candidate counts, and example candidate IDs. If a requested adapter, identifier, or candidate pool does not match the source, inspection returns the same discovery result with an explanation and suggested adapter instead of `PROBABILITY_SURFACE_EMPTY`; evaluation, sweeps, and simulation remain strict and still reject an empty requested surface.
+Pass a source without an adapter when the surface type is not yet known. Inspection returns every compatible adapter, candidate counts, and example candidate IDs. If a requested adapter, identifier, or candidate pool does not match the source, inspection returns the same discovery result with an explanation and suggested adapter instead of `PROBABILITY_SURFACE_EMPTY`.
+
+Evaluation, sweep, simulation, and source comparison also accept an omitted adapter. When a source selector identifies one unambiguous weighted surface, the analyzer selects that source-backed adapter automatically. If a caller supplies a mismatched adapter or `custom_weighted_pool` for a source-backed request, the analyzer corrects it when the source has exactly one match. `customPoolManifest`, `beforeManifest`, and `afterManifest` use the custom-pool adapter automatically; `PROBABILITY_SURFACE_EMPTY` is reserved for sources with no weighted surface, while genuinely multi-adapter sources ask the caller to narrow by identifier or line.
 
 ## Scenarios
 

package/docs/technology.md

@@ -49,7 +49,7 @@ Game-backed and otherwise large workspaces automatically use focused analysis mo
 
 ## Render
 
-`hoi4.tech_render` returns authoritative JSON with deterministic SVG and PNG resources; set `includeHtml` when a bundled static report is useful. Available views are `summary`, `folder`, `dependencies`, `technology`, `doctrine`, `exclusive`, `memberships`, `bonuses`, `grants`, `unlocks`, `metadata`, `assets`, and `unresolved`.
+`hoi4.tech_render` returns authoritative JSON with deterministic SVG and PNG resources; set `includeHtml` when a bundled static report is useful. Folder renders read the actual `techtree_<folder>_item` and `techtree_<folder>_small_item` geometry, choose the small item for technologies that do not unlock equipment or explicitly force it, and include the source GUI's horizontal or vertical year guide. Available views are `summary`, `folder`, `dependencies`, `technology`, `doctrine`, `exclusive`, `memberships`, `bonuses`, `grants`, `unlocks`, `metadata`, `assets`, and `unresolved`.
 
 Folder renders use the actual folder assignments, gridbox geometry, technology coordinates, and HOI4 item size found in source. Technologies with `force_use_small_tech_layout = yes` render as compact icon items; normal technologies render as large items with their icon and label. Sprite declarations and texture files resolve through the active load order across the mod, configured dependencies, and the detected or configured game installation, so vanilla icons used by a mod appear in SVG, PNG, and HTML artifacts. The authoritative JSON and SVG expose `layoutSize`, rendered-icon coverage, and unresolved sprite names without embedding image data in JSON. Dependency and other semantic views are explicitly labelled as generated analysis layouts.
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "hoi4-agent-tools",
   "mcpName": "io.github.klimPaskov/hoi4-agent-tools",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Analyze HOI4 events, tech trees, AI weights, and MTTH; build focus trees, GUIs, and maps.",
   "type": "module",
   "license": "Apache-2.0",

package/schemas/configuration.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.0.0/schemas/configuration.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.0.2/schemas/configuration.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/continuous-focus-palette.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.0.0/schemas/continuous-focus-palette.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.0.2/schemas/continuous-focus-palette.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/custom-weighted-pool.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.0.0/schemas/custom-weighted-pool.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.0.2/schemas/custom-weighted-pool.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {

package/schemas/event-feature-manifest.schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.0.0/schemas/event-feature-manifest.schema.json",
+  "$id": "https://github.com/klimPaskov/hoi4-agent-tools/blob/v3.0.2/schemas/event-feature-manifest.schema.json",
   "$schema": "https://json-schema.org/draft/2020-12/schema",
   "type": "object",
   "properties": {