hoi4-agent-tools 3.0.0 → 3.0.1

package/dist/hoi4_agent_tools/probability/service.js

@@ -17,6 +17,43 @@ import { Rational } from './rational.js';
 import { discoverWeightedSurface, inventoryWeightedSurfaces, } from './source-analysis.js';
 import { sweepSurface } from './sweep.js';
 const states = new WeakMap();
+function resolveSourceBackedAdapter(snapshot, source, candidatePool, requested) {
+    if (requested !== undefined && requested !== 'custom_weighted_pool') {
+        try {
+            discoverWeightedSurface(snapshot, requested, source, candidatePool);
+            return requested;
+        }
+        catch (error) {
+            if (!(error instanceof ServiceError) ||
+                (error.code !== 'PROBABILITY_SURFACE_EMPTY' &&
+                    error.code !== 'PROBABILITY_IDENTIFIER_NOT_FOUND'))
+                throw error;
+        }
+    }
+    const inventory = inventoryWeightedSurfaces(snapshot, source, candidatePool);
+    const viable = inventory.adapters
+        .filter(({ candidateCount, identifierMatchCount, candidatePoolMatchCount }) => candidateCount > 0 &&
+        (source.identifier === undefined || identifierMatchCount > 0) &&
+        (candidatePool.length === 0 || candidatePoolMatchCount > 0))
+        .sort((left, right) => right.identifierMatchCount - left.identifierMatchCount ||
+        right.candidatePoolMatchCount - left.candidatePoolMatchCount ||
+        right.candidateCount - left.candidateCount ||
+        compareCodeUnits(left.adapterId, right.adapterId));
+    if (viable.length === 1)
+        return viable[0].adapterId;
+    if (viable.length === 0)
+        throw new ServiceError('PROBABILITY_SURFACE_EMPTY', 'No weighted blocks matched this request', {
+            requestedAdapter: requested,
+            source,
+            candidatePool,
+            availableAdapters: inventory.adapters.filter(({ candidateCount }) => candidateCount > 0),
+        });
+    throw new ServiceError('PROBABILITY_ADAPTER_AMBIGUOUS', 'Several weighted adapters match this source; select one adapter or narrow the source by identifier or line', {
+        requestedAdapter: requested,
+        source,
+        matchingAdapters: viable,
+    });
+}
 function analyzerState(engine) {
     let state = states.get(engine);
     if (state === undefined) {
@@ -853,7 +890,9 @@ export class ProbabilityAnalyzer {
             return { adapters: probabilityAdapters(), artifacts: [], filesScanned: [] };
         if (customPoolManifest !== undefined && source !== undefined)
             throw new ServiceError('PROBABILITY_INPUT_AMBIGUOUS', 'Provide either source or customPoolManifest for inspection');
-        if (customPoolManifest !== undefined && adapter !== 'custom_weighted_pool')
+        if (customPoolManifest !== undefined &&
+            adapter !== undefined &&
+            adapter !== 'custom_weighted_pool')
             throw new ServiceError('PROBABILITY_ADAPTER_MISMATCH', 'customPoolManifest inspection requires adapter custom_weighted_pool');
         const snapshot = await this.scan(context, [source?.path], source === undefined ? 'none' : source.inlineClausewitz === undefined ? 'domain' : 'shared');
         if (customPoolManifest !== undefined) {
@@ -1040,15 +1079,18 @@ export class ProbabilityAnalyzer {
         const usingManifest = request.customPoolManifest !== undefined;
         if (usingManifest !== (request.source === undefined))
             throw new ServiceError('PROBABILITY_INPUT_AMBIGUOUS', 'Provide exactly one source or customPoolManifest');
-        if (usingManifest && request.adapter !== 'custom_weighted_pool')
+        if (usingManifest &&
+            request.adapter !== undefined &&
+            request.adapter !== 'custom_weighted_pool')
             throw new ServiceError('PROBABILITY_ADAPTER_MISMATCH', 'customPoolManifest requires the custom_weighted_pool adapter');
-        if (!usingManifest && request.adapter === 'custom_weighted_pool')
-            throw new ServiceError('PROBABILITY_MANIFEST_REQUIRED', 'custom_weighted_pool requires customPoolManifest');
-        const gameVersionVerification = await this.verifyGameVersion(request, request.adapter);
         const snapshot = await this.scan(request, [request.source?.path], usingManifest ? 'none' : request.source?.inlineClausewitz === undefined ? 'domain' : 'shared');
+        const resolvedAdapter = usingManifest
+            ? 'custom_weighted_pool'
+            : resolveSourceBackedAdapter(snapshot, request.source, request.candidatePool ?? [], request.adapter);
+        const gameVersionVerification = await this.verifyGameVersion(request, resolvedAdapter);
         const surface = usingManifest
             ? customSurface(request.customPoolManifest, snapshot.revision)
-            : discoverWeightedSurface(snapshot, request.adapter, request.source, request.candidatePool ?? []);
+            : discoverWeightedSurface(snapshot, resolvedAdapter, request.source, request.candidatePool ?? []);
         const definitions = ClausewitzEvaluationDefinitions.build(snapshot);
         const metadata = this.metadata(request, snapshot, surface, request.scenarioSet, usingManifest
             ? request.customPoolManifest.candidates.map(({ id }) => id)

package/dist/hoi4_agent_tools/technology/compare.js

@@ -4,12 +4,17 @@ function byId(values) {
 }
 function placementSignature(values) {
     return hashCanonical(values
-        .map(({ folderId, x, y, xExpression, yExpression }) => ({
+        .map(({ folderId, x, y, xExpression, yExpression, layoutSize, layoutWidth, layoutHeight, layoutOffsetX, layoutOffsetY, }) => ({
         folderId,
         x: x ?? null,
         y: y ?? null,
         xExpression: xExpression ?? null,
         yExpression: yExpression ?? null,
+        layoutSize: layoutSize ?? null,
+        layoutWidth: layoutWidth ?? null,
+        layoutHeight: layoutHeight ?? null,
+        layoutOffsetX: layoutOffsetX ?? null,
+        layoutOffsetY: layoutOffsetY ?? null,
     }))
         .sort((left, right) => compareCodeUnits(left.folderId, right.folderId) ||
         (left.x ?? 0) - (right.x ?? 0) ||

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.1';
 export const MCP_PROTOCOL_VERSION = LATEST_PROTOCOL_VERSION;
 export const CONFIG_VERSION = 1;
 export const TRANSACTION_VERSION = 1;