hoi4-agent-tools 3.4.0 → 3.5.0

package/dist/hoi4_agent_tools/gui/layout.js

@@ -1172,7 +1172,11 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     const clipChain = inheritedClipChain ?? (inheritedClip === undefined ? [] : [inheritedClip]);
     const localScale = scalarNumber(property(definition.attributes, 'scale'), 1) ?? 1;
     const scale = parentScale * localScale;
-    const position = objectProperty(property(definition.attributes, 'position'));
+    const shownPosition = depth === 0 ? objectProperty(property(definition.attributes, 'show_position')) : undefined;
+    const position = shownPosition ?? objectProperty(property(definition.attributes, 'position'));
+    if (shownPosition !== undefined) {
+        addFidelity(fidelity, 'modelled', 'window_show_position', 'The requested root window uses its declared settled show position.', definition);
+    }
     const size = objectProperty(property(definition.attributes, 'size'));
     const scriptedX = rowValues?.[`${definition.name}.x`] ??
         scenario.values[`${definition.name}.x`] ??
@@ -1196,8 +1200,22 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     const orientationAxes = anchorAxes(orientation);
     const anchorX = anchoredCoordinate(parentRect.x, parentRect.width, localX, orientationAxes.horizontal);
     const anchorY = anchoredCoordinate(parentRect.y, parentRect.height, localY, orientationAxes.vertical);
-    const widthValue = size === undefined ? undefined : property(size, 'width', 'x');
-    const heightValue = size === undefined ? undefined : property(size, 'height', 'y');
+    const scriptedWidth = rowValues?.[`${definition.name}.width`] ??
+        scenario.values[`${definition.name}.width`] ??
+        scenario.scriptedGui[`${definition.name}.width`];
+    const scriptedHeight = rowValues?.[`${definition.name}.height`] ??
+        scenario.values[`${definition.name}.height`] ??
+        scenario.scriptedGui[`${definition.name}.height`];
+    const widthValue = typeof scriptedWidth === 'number' && Number.isFinite(scriptedWidth)
+        ? scriptedWidth
+        : size === undefined
+            ? undefined
+            : property(size, 'width', 'x');
+    const heightValue = typeof scriptedHeight === 'number' && Number.isFinite(scriptedHeight)
+        ? scriptedHeight
+        : size === undefined
+            ? undefined
+            : property(size, 'height', 'y');
     let width = scaledNumber(widthValue, parentRect.width, scale) ?? 0;
     let height = scaledNumber(heightValue, parentRect.height, scale) ?? 0;
     // A doubled percent names a far-edge coordinate in the parent, whereas a single
@@ -1455,10 +1473,17 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             width = declaredMaxWidth;
         if (width === 0 && inferWidth && /textbox/iu.test(definition.elementType))
             width = nativeTextBoxWidth * scale;
-        if (height === 0 && inferHeight && declaredMaxHeight !== undefined)
+        const inferredTextHeight = height === 0 && inferHeight;
+        if (inferredTextHeight && declaredMaxHeight !== undefined)
             height = declaredMaxHeight;
         const maxWidth = declaredMaxWidth ?? width;
-        const wrapped = wrapText(catalog, fontName, displayText, visibleText.colours, fontSize * scale, maxWidth, context.work, resolvedInlineIcons);
+        const wrapped = wrapText(catalog, fontName, displayText, visibleText.colours, fontSize * scale, scalarBoolean(property(definition.attributes, 'multiline')) === false ? 0 : maxWidth, context.work, resolvedInlineIcons);
+        // Native maxHeight text boxes retain at least one font line. Explicit size
+        // rectangles and inherited parent clipping still constrain their pixels.
+        if (inferredTextHeight && declaredMaxHeight !== undefined && height < wrapped.lineHeight) {
+            height = wrapped.lineHeight;
+            addFidelity(fidelity, 'approximated', 'text_minimum_line_height', 'An inferred maxHeight smaller than one font line retains the first line; this native layout convention has no engine capture in this scenario.', definition);
+        }
         const glyphLines = [];
         const inlineIcons = [];
         for (const [lineIndex, line] of wrapped.lines.entries()) {
@@ -1747,7 +1772,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     if (state === 'full-list' && rows === undefined)
         rows = Array.from({ length: 12 }, (_unused, index) => ({ index }));
     const dynamicList = context.dynamicListsByName.get(definition.name);
-    const listElement = /(?:grid|listbox|overlappingelements)/iu.test(definition.elementType);
+    const listElement = /(?:grid|listbox|overlappingelements|positiontype)/iu.test(definition.elementType);
     const slotSize = objectProperty(property(definition.attributes, 'slotsize'));
     const slotHeight = scaledNumber(slotSize === undefined ? undefined : property(slotSize, 'height', 'y'), height, scale);
     const slotWidth = scaledNumber(slotSize === undefined ? undefined : property(slotSize, 'width', 'x'), width, scale);
@@ -1761,8 +1786,13 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
     const maxHorizontal = scalarNumber(property(definition.attributes, 'max_slots_horizontal'), 1);
     const maxVertical = scalarNumber(property(definition.attributes, 'max_slots_vertical'), 1);
     const grid = /grid/iu.test(definition.elementType);
+    const singleColumnFlow = grid &&
+        maxHorizontal === 1 &&
+        slotHeight !== undefined &&
+        slotHeight <= scale &&
+        (maxVertical === undefined || maxVertical <= 0);
     const rowPosition = (index, fallbackY) => {
-        if (!grid || slotWidth === undefined || slotHeight === undefined)
+        if (!grid || singleColumnFlow || slotWidth === undefined || slotHeight === undefined)
             return { x: 0, y: fallbackY };
         if (maxVertical !== undefined && maxVertical > 0) {
             const rowsPerColumn = Math.max(1, Math.trunc(maxVertical));
@@ -1822,11 +1852,22 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
                 (row.countryScope === true
                     ? (dynamicList?.countryScopeEntryContainer ?? dynamicList?.entryContainer)
                     : (dynamicList?.entryContainer ?? dynamicList?.countryScopeEntryContainer));
-            const template = templateName === undefined ? undefined : context.elementsByName.get(templateName);
+            const candidates = templateName === undefined
+                ? []
+                : (context.elementsByNameCandidates.get(templateName) ?? []);
+            const localCandidates = candidates.filter(({ sourcePath }) => sourcePath === definition.sourcePath);
+            const localRoots = localCandidates.filter(({ parentId }) => parentId === undefined);
+            const template = localRoots.length === 1
+                ? localRoots[0]
+                : localCandidates.length === 1
+                    ? localCandidates[0]
+                    : candidates.length === 1
+                        ? candidates[0]
+                        : undefined;
             if (template === undefined) {
                 diagnostics.push(diagnostic('GUI_DYNAMIC_LIST_TEMPLATE_MISSING', 'error', templateName === undefined
                     ? `Dynamic list ${definition.name} has no entry container for scenario row ${index}.`
-                    : `Dynamic list ${definition.name} cannot resolve entry container ${templateName}.`, definition));
+                    : `Dynamic list ${definition.name} cannot unambiguously resolve entry container ${templateName}.`, definition));
                 continue;
             }
             const templatePosition = objectProperty(property(template.attributes, 'position'));
@@ -1842,7 +1883,7 @@ async function layoutElement(definition, parentRect, inheritedClip, parentScale,
             };
             await layoutElement(template, shiftedParent, childClip, scale, depth + 1, context, rowSuffix(index), index, row, instanceId, origo, resolveVisibleAppearance, childClipChain);
             const rendered = context.instancesById.get(`${template.id}${rowSuffix(index)}`);
-            rowY += (slotHeight ?? rendered?.unclippedRect.height ?? 0) + spacingY;
+            rowY += Math.max(slotHeight ?? 0, rendered?.unclippedRect.height ?? 0) + spacingY;
             renderedRows += 1;
         }
         addFidelity(fidelity, renderedRows === rows.length ? 'modelled' : 'missing', dynamicList === undefined ? 'native_dynamic_list' : 'scripted_gui_dynamic_list', `Expanded ${renderedRows}/${rows.length} scenario rows for ${definition.name} through ${dynamicList === undefined ? 'explicit native' : 'scripted-GUI'} entry containers.`, definition);
@@ -2055,10 +2096,15 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
     };
     const output = [];
     const elementsByName = new Map();
+    const elementsByNameCandidates = new Map();
     for (const element of [...graph.elements].sort((left, right) => compareCodeUnits(right.sourcePath, left.sourcePath) ||
-        right.definitionOrder - left.definitionOrder))
+        right.definitionOrder - left.definitionOrder)) {
         if (!elementsByName.has(element.name))
             elementsByName.set(element.name, element);
+        const candidates = elementsByNameCandidates.get(element.name) ?? [];
+        candidates.push(element);
+        elementsByNameCandidates.set(element.name, candidates);
+    }
     const context = {
         graph,
         scenario: layoutScenario,
@@ -2067,6 +2113,7 @@ export async function buildGuiScene(graph, scannedFiles, windowName, scenario, c
         diagnostics,
         elementsById,
         elementsByName,
+        elementsByNameCandidates,
         dynamicListsByName,
         countryFlagProperties,
         constantElementEnabled,

package/dist/hoi4_agent_tools/gui/scenario.js

@@ -1,5 +1,5 @@
 import { z } from 'zod';
-import { ConditionScopeBindingSchema, ConditionResultSchema } from '../core/condition-schema.js';
+import { ConditionScopeBindingSchema, ConditionResultSchema, ConditionControlMapSchema, GuiScenarioDateSchema, } from '../core/condition-schema.js';
 import { renderDimensionViolation, RENDER_MAX_DIMENSION } from '../core/render-budget.js';
 import { ServiceError } from '../core/result.js';
 import { GUI_SCENARIO_MAX_KEYS, GUI_SCENARIO_MAX_LIST_KEYS, GUI_SCENARIO_MAX_ROWS, GUI_SCENARIO_MAX_STRING_CHARACTERS, } from './limits.js';
@@ -104,6 +104,8 @@ const GuiPreviewScenarioBodySchema = z
         .max(128)
         .regex(/^[A-Za-z0-9][A-Za-z0-9._-]*$/u),
     description: z.string().max(500).optional(),
+    date: GuiScenarioDateSchema.optional(),
+    controls: ConditionControlMapSchema.optional(),
     resolution: GuiPreviewResolutionSchema.default({ width: 1920, height: 1080 }),
     uiScale: z
         .number()

package/dist/hoi4_agent_tools/gui/source-graph.js

@@ -56,6 +56,7 @@ const modelledElementAttributes = new Set([
     'maxWidth',
     'maxHeight',
     'fixedsize',
+    'multiline',
     'format',
     'buttonText',
     'buttonFont',
@@ -1292,7 +1293,7 @@ function referenceLabel(edge) {
         return String(value);
     return value === undefined ? edge.to : JSON.stringify(value);
 }
-export function buildGuiSourceGraph(files, sharedIndex) {
+export function buildGuiSourceGraph(files, sharedIndex, additionalLocalisationKeys = []) {
     const activeFiles = files.filter(({ shadowedBy }) => shadowedBy === undefined);
     const nodes = [];
     const edges = [];
@@ -1435,6 +1436,8 @@ export function buildGuiSourceGraph(files, sharedIndex) {
         indexDecisionEntries(document, file, nodes, pendingDecisionEdges);
     }
     const referencedLocalisationKeys = referencedGuiLocalisationKeys(elements, scriptedLocalisation);
+    for (const key of additionalLocalisationKeys)
+        referencedLocalisationKeys.add(key);
     for (const { file, fileNodeId } of localisationFiles.sort((left, right) => right.file.loadOrder - left.file.loadOrder ||
         compareCodeUnits(left.file.displayPath, right.file.displayPath))) {
         const document = parseLocalisation(file.bytes, file.displayPath);

package/dist/hoi4_agent_tools/gui/studio.js

@@ -498,6 +498,24 @@ function scenarioTemplateNames(scenarios) {
         ...new Set(scenarios.flatMap(({ lists }) => Object.values(lists).flatMap((rows) => rows.flatMap(({ entryContainer }) => typeof entryContainer === 'string' && entryContainer.length > 0 ? [entryContainer] : [])))),
     ].sort(compareCodeUnits);
 }
+function scenarioLocalisationKeys(scenarios) {
+    const keys = new Set();
+    const pending = [...scenarios];
+    while (pending.length > 0) {
+        const value = pending.pop();
+        if (typeof value === 'string') {
+            if (/^[A-Za-z0-9_.-]{1,512}$/u.test(value))
+                keys.add(value);
+            for (const match of value.matchAll(/\$([A-Za-z0-9_.-]+)\$/gu))
+                keys.add(match[1]);
+        }
+        else if (Array.isArray(value))
+            pending.push(...value);
+        else if (value !== null && typeof value === 'object')
+            pending.push(...Object.values(value));
+    }
+    return [...keys].sort(compareCodeUnits);
+}
 /** Native row bindings admit only bounded country tokens, never caller-supplied paths or globs. */
 export function scenarioCountryFlagPatterns(scenarios) {
     const tags = new Set();
@@ -861,8 +879,8 @@ export class ScriptedGuiStudio {
         this.scanner = this.engine.scanner;
         this.artifacts = this.engine.artifacts;
     }
-    graphForFiles(files, scope) {
-        const key = `${scope}:${hashCanonical(files.map(({ displayPath, sha256, shadowedBy }) => ({
+    graphForFiles(files, scope, additionalLocalisationKeys = []) {
+        const key = `${scope}:${hashCanonical(additionalLocalisationKeys)}:${hashCanonical(files.map(({ displayPath, sha256, shadowedBy }) => ({
             displayPath,
             sha256,
             ...(shadowedBy === undefined ? {} : { shadowedBy }),
@@ -876,7 +894,7 @@ export class ScriptedGuiStudio {
         const retainedFiles = [...files];
         const scanned = {
             files: retainedFiles,
-            graph: buildGuiSourceGraph(retainedFiles, this.engine.indexFiles(retainedFiles)),
+            graph: buildGuiSourceGraph(retainedFiles, this.engine.indexFiles(retainedFiles), additionalLocalisationKeys),
         };
         this.#graphCache.set(key, scanned);
         while (this.#graphCache.size > 1) {
@@ -906,7 +924,7 @@ export class ScriptedGuiStudio {
         const files = mergeScannedFiles(snapshot.files, localisationFiles);
         return this.graphForFiles(files, `workspace:${workspaceId}`);
     }
-    async scanWindow(workspaceId, windowName, principal, signal, languages = ['l_english'], additionalSpriteNames = [], additionalTemplateNames = [], additionalAssetPatterns = []) {
+    async scanWindow(workspaceId, windowName, principal, signal, languages = ['l_english'], additionalSpriteNames = [], additionalTemplateNames = [], additionalAssetPatterns = [], additionalLocalisationKeys = []) {
         const workspace = this.resolver.get(workspaceId, principal);
         const layoutPatterns = guiLayoutPatterns(workspace);
         const overlayLayouts = await this.engine.scan(workspaceId, {
@@ -934,7 +952,7 @@ export class ScriptedGuiStudio {
             this.engine.scan(workspaceId, { patterns: guiLocalisationPatterns(workspace, languages) }, principal, signal),
         ]);
         const definitionFiles = mergeScannedFiles(layoutFiles, linkedDefinitions.files, localisation.files);
-        const definitions = this.graphForFiles(definitionFiles, `definitions:${workspaceId}`);
+        const definitions = this.graphForFiles(definitionFiles, `definitions:${workspaceId}`, additionalLocalisationKeys);
         assertTargetWindowAvailable(definitions.graph, windowName);
         const referencedPatterns = [
             ...referencedAssetPatternsForWindow(definitions.graph, windowName, additionalSpriteNames, languages, additionalTemplateNames),
@@ -973,7 +991,7 @@ export class ScriptedGuiStudio {
         const fontPages = mergeScannedFiles(exactFontPages, fallbackFontPages);
         signal?.throwIfAborted();
         const files = mergeScannedFiles(definitions.files, referenced, fontPages);
-        return this.graphForFiles(files, `window:${workspaceId}:${windowName}`);
+        return this.graphForFiles(files, `window:${workspaceId}:${windowName}`, additionalLocalisationKeys);
     }
     async lint(input) {
         input.signal?.throwIfAborted();
@@ -982,7 +1000,7 @@ export class ScriptedGuiStudio {
         const generatedOptions = input.generatedScenarios === undefined
             ? undefined
             : parseGeneratedScenarioOptions(input.generatedScenarios);
-        const scanned = await this.scanWindow(input.workspaceId, input.windowName, input.principal, input.signal, [placeholderScenario.language, ...explicitRelatedScenarios.map(({ language }) => language)], scenarioSpriteNames([placeholderScenario, ...explicitRelatedScenarios], generatedOptions?.textSamples), scenarioTemplateNames([placeholderScenario, ...explicitRelatedScenarios]), scenarioCountryFlagPatterns([placeholderScenario, ...explicitRelatedScenarios]));
+        const scanned = await this.scanWindow(input.workspaceId, input.windowName, input.principal, input.signal, [placeholderScenario.language, ...explicitRelatedScenarios.map(({ language }) => language)], scenarioSpriteNames([placeholderScenario, ...explicitRelatedScenarios], generatedOptions?.textSamples), scenarioTemplateNames([placeholderScenario, ...explicitRelatedScenarios]), scenarioCountryFlagPatterns([placeholderScenario, ...explicitRelatedScenarios]), scenarioLocalisationKeys([placeholderScenario, ...explicitRelatedScenarios]));
         const generatedScenarios = generatedOptions === undefined
             ? []
             : generateGuiPreviewScenarios(scanned.graph, input.windowName, placeholderScenario, generatedOptions, ClausewitzEvaluationDefinitions.build(scanned));
@@ -1012,7 +1030,7 @@ export class ScriptedGuiStudio {
         const budget = new RenderBudget();
         const beforeScenario = parsePreviewScenario(input.before);
         const afterScenario = parsePreviewScenario(input.after);
-        const scanned = await this.scanWindow(input.workspaceId, input.windowName, input.principal, input.signal, [beforeScenario.language, afterScenario.language], scenarioSpriteNames([beforeScenario, afterScenario]), scenarioTemplateNames([beforeScenario, afterScenario]), scenarioCountryFlagPatterns([beforeScenario, afterScenario]));
+        const scanned = await this.scanWindow(input.workspaceId, input.windowName, input.principal, input.signal, [beforeScenario.language, afterScenario.language], scenarioSpriteNames([beforeScenario, afterScenario]), scenarioTemplateNames([beforeScenario, afterScenario]), scenarioCountryFlagPatterns([beforeScenario, afterScenario]), scenarioLocalisationKeys([beforeScenario, afterScenario]));
         const beforeCatalog = new GuiAssetCatalog(scanned.graph, scanned.files, budget, beforeScenario.language);
         const afterCatalog = new GuiAssetCatalog(scanned.graph, scanned.files, budget, afterScenario.language);
         const before = await buildGuiScene(scanned.graph, scanned.files, input.windowName, beforeScenario, beforeCatalog);
@@ -1069,6 +1087,10 @@ export class ScriptedGuiStudio {
             placeholderScenario,
             ...(requestedBaselineScenario === undefined ? [] : [requestedBaselineScenario]),
             ...explicitRelatedScenarios,
+        ]), scenarioLocalisationKeys([
+            placeholderScenario,
+            ...(requestedBaselineScenario === undefined ? [] : [requestedBaselineScenario]),
+            ...explicitRelatedScenarios,
         ]));
         const generatedScenarios = generatedOptions === undefined
             ? []
@@ -1177,7 +1199,7 @@ export class ScriptedGuiStudio {
                     loadOrder: original.loadOrder,
                 },
             ]);
-            const baselineGraph = this.graphForFiles(baselineFiles, `source-baseline:${input.workspaceId}`).graph;
+            const baselineGraph = this.graphForFiles(baselineFiles, `source-baseline:${input.workspaceId}`, scenarioLocalisationKeys([scenario])).graph;
             if (!baselineGraph.elements.some(({ name }) => name === input.windowName))
                 throw new ServiceError('GUI_SOURCE_BASELINE_WINDOW_MISSING', 'Source baseline does not define the requested GUI window', { relativePath, windowName: input.windowName });
             sourceBaselineScene = await buildGuiScene(baselineGraph, baselineFiles, input.windowName, scenario, new GuiAssetCatalog(baselineGraph, baselineFiles, budget, scenario.language));
@@ -1416,7 +1438,7 @@ export class ScriptedGuiStudio {
         const previewScenario = input.scenario === undefined ? undefined : parsePreviewScenario(input.scenario);
         const initiallyScanned = input.windowName === undefined
             ? await this.scan(input.workspaceId, input.principal, input.signal)
-            : await this.scanWindow(input.workspaceId, input.windowName, input.principal, input.signal, [previewScenario.language], scenarioSpriteNames([previewScenario]), scenarioTemplateNames([previewScenario]), scenarioCountryFlagPatterns([previewScenario]));
+            : await this.scanWindow(input.workspaceId, input.windowName, input.principal, input.signal, [previewScenario.language], scenarioSpriteNames([previewScenario]), scenarioTemplateNames([previewScenario]), scenarioCountryFlagPatterns([previewScenario]), scenarioLocalisationKeys([previewScenario]));
         const exactTargets = await this.scanner.scan(workspace, {
             patterns: prepared.map(({ relativePath }) => relativePath),
             ...(input.signal === undefined ? {} : { signal: input.signal }),

package/dist/hoi4_agent_tools/gui/validators.js

@@ -655,6 +655,9 @@ function validateReferencesAndScript(graph, scene, diagnostics) {
         const elementsById = new Map(graph.elements.map((element) => [element.id, element]));
         for (const button of scene.elements.filter(({ elementType }) => /button/iu.test(elementType))) {
             const source = elementsById.get(button.sourceId);
+            const referencedByScript = effects.has(button.name) || triggers.has(button.name);
+            if ((source === undefined || !/button/iu.test(source.elementType)) && !referencedByScript)
+                continue;
             const tooltipOnly = !effects.has(button.name) &&
                 !triggers.has(button.name) &&
                 (typeof source?.attributes.pdx_tooltip === 'string' ||

package/dist/hoi4_agent_tools/map/model.js

@@ -169,6 +169,39 @@ function parseNumber(value) {
     const parsed = Number(value);
     return Number.isFinite(parsed) ? parsed : undefined;
 }
+export function parseMapDate(value) {
+    const match = /^(\d{1,4})\.(\d{1,2})\.(\d{1,2})(?:\.(\d{1,2}))?$/u.exec(value);
+    if (match === null)
+        return undefined;
+    const year = Number(match[1]);
+    const month = Number(match[2]);
+    const day = Number(match[3]);
+    const hour = match[4] === undefined ? 0 : Number(match[4]);
+    if (year < 1 || month < 1 || month > 12 || day < 1 || day > 31 || hour < 0 || hour > 23)
+        return undefined;
+    return year * 1_000_000 + month * 10_000 + day * 100 + hour;
+}
+function earliestBookmarkDate(files) {
+    let earliest;
+    for (const file of files) {
+        if (!/^common\/bookmarks\/.*\.txt$/iu.test(normalizedPath(file.relativePath)))
+            continue;
+        const document = parseClausewitz(file.bytes, file.displayPath);
+        for (const root of childBlocks(document.root, 'bookmarks')) {
+            for (const bookmark of childBlocks(root, 'bookmark')) {
+                const value = firstScalar(bookmark, 'date')?.value;
+                if (value === undefined)
+                    continue;
+                const ordinal = parseMapDate(value);
+                if (ordinal === undefined)
+                    continue;
+                if (earliest === undefined || ordinal < earliest.ordinal)
+                    earliest = { value, ordinal, sourcePath: file.displayPath };
+            }
+        }
+    }
+    return earliest;
+}
 function requiredNumber(values, index, label) {
     const value = values[index];
     if (value === undefined) {
@@ -260,7 +293,7 @@ export function parseDefinitions(file, diagnostics) {
     }
     return definitions;
 }
-export function parseState(file, diagnostics) {
+export function parseState(file, diagnostics, earliestBookmark) {
     const document = parseClausewitz(file.bytes, file.displayPath);
     addMapDiagnostics(diagnostics, document.diagnostics);
     const assignment = firstTopLevelAssignment(document, 'state');
@@ -318,8 +351,85 @@ export function parseState(file, diagnostics) {
             }
         }
     }
-    const owner = firstScalar(historyBlock ?? block, 'owner')?.value;
-    const controller = firstScalar(historyBlock ?? block, 'controller')?.value;
+    let owner = firstScalar(historyBlock ?? block, 'owner')?.value;
+    let controller = firstScalar(historyBlock ?? block, 'controller')?.value;
+    let cores = historyBlock === undefined
+        ? []
+        : assignments(historyBlock, 'add_core_of').flatMap(({ value }) => value.type === 'scalar' ? [value.value] : []);
+    let claims = historyBlock === undefined
+        ? []
+        : assignments(historyBlock, 'add_claim_by').flatMap(({ value }) => value.type === 'scalar' ? [value.value] : []);
+    if (historyBlock !== undefined) {
+        const dated = assignments(historyBlock)
+            .flatMap((entry) => {
+            if (entry.value.type !== 'block')
+                return [];
+            const date = parseMapDate(entry.key.value);
+            return date === undefined ? [] : [{ entry, date }];
+        })
+            .sort((left, right) => left.date - right.date || left.entry.start - right.entry.start);
+        if (dated.length > 0 && earliestBookmark === undefined) {
+            addMapDiagnostic(diagnostics, {
+                code: 'MAP_STATE_DATED_HISTORY_UNRESOLVED',
+                severity: 'warning',
+                category: 'map',
+                message: `State ${id} has dated history but no active bookmark date was found`,
+                location: nodeLocation(document, dated[0].entry),
+            });
+        }
+        for (const { entry, date } of dated) {
+            if (earliestBookmark === undefined || date >= earliestBookmark.ordinal)
+                continue;
+            if (entry.value.type !== 'block')
+                continue;
+            for (const command of assignments(entry.value)) {
+                const value = command.value;
+                if (value.type === 'scalar') {
+                    if (command.key.value === 'owner')
+                        owner = value.value;
+                    else if (command.key.value === 'controller')
+                        controller = value.value;
+                    else if (command.key.value === 'add_core_of' && !cores.includes(value.value))
+                        cores.push(value.value);
+                    else if (command.key.value === 'remove_core_of')
+                        cores = cores.filter((tag) => tag !== value.value);
+                    else if (command.key.value === 'add_claim_by' && !claims.includes(value.value))
+                        claims.push(value.value);
+                    else if (command.key.value === 'remove_claim_by')
+                        claims = claims.filter((tag) => tag !== value.value);
+                }
+                else if (command.key.value === 'victory_points') {
+                    const values = scalarList(value);
+                    const provinceId = parseInteger(values[0]);
+                    const amount = parseNumber(values[1]);
+                    if (provinceId === undefined || amount === undefined)
+                        continue;
+                    const existing = victoryPoints.findIndex((point) => point.provinceId === provinceId);
+                    if (existing >= 0)
+                        victoryPoints.splice(existing, 1);
+                    victoryPoints.push({ provinceId, value: amount, assignment: command });
+                }
+                else if (command.key.value === 'buildings') {
+                    for (const building of assignments(value)) {
+                        if (building.value.type === 'block') {
+                            const provinceId = parseInteger(building.key.value);
+                            if (provinceId === undefined)
+                                continue;
+                            const merged = new Map(provinceBuildings.get(provinceId) ?? []);
+                            for (const [key, level] of numericMap(building.value))
+                                merged.set(key, level);
+                            provinceBuildings.set(provinceId, merged);
+                        }
+                        else {
+                            const level = parseNumber(building.value.value);
+                            if (level !== undefined)
+                                stateBuildings.set(building.key.value, level);
+                        }
+                    }
+                }
+            }
+        }
+    }
     const capital = derivedStateCapital(victoryPoints);
     return {
         id,
@@ -331,12 +441,8 @@ export function parseState(file, diagnostics) {
         resources: numericMap(resourcesBlock),
         ...(owner === undefined ? {} : { owner }),
         ...(controller === undefined ? {} : { controller }),
-        cores: historyBlock === undefined
-            ? []
-            : assignments(historyBlock, 'add_core_of').flatMap(({ value }) => value.type === 'scalar' ? [value.value] : []),
-        claims: historyBlock === undefined
-            ? []
-            : assignments(historyBlock, 'add_claim_by').flatMap(({ value }) => value.type === 'scalar' ? [value.value] : []),
+        cores,
+        claims,
         victoryPoints,
         provinceBuildings,
         stateBuildings,
@@ -825,6 +931,7 @@ export class MapWorkspaceIndex {
     /** Shared cross-domain symbol/reference authority for these exact source bytes. */
     sharedIndex;
     activeFiles;
+    earliestBookmark;
     diagnostics = [];
     definitions;
     definitionsAcrossRoots;
@@ -875,6 +982,7 @@ export class MapWorkspaceIndex {
             localisation: sourceRoots.localisation.map(normalizeConfiguredRoot),
         };
         this.activeFiles = selectActiveFiles(files);
+        this.earliestBookmark = earliestBookmarkDate(this.activeFiles.all);
         const modelBudget = new MapModelBudget();
         modelBudget.assertScriptFiles(this.sourceFiles.filter((file) => inConfiguredRoot(file.relativePath, this.sourceRoots.states) ||
             this.sourceRoots.map.some((root) => normalizedPath(file.relativePath).startsWith(`${root}/strategicregions/`)) ||
@@ -935,7 +1043,9 @@ export class MapWorkspaceIndex {
             const cached = parsedStates.get(file.displayPath);
             if (cached !== undefined)
                 return cached ?? undefined;
-            const state = parseState(file, activeStatePaths.has(file.displayPath) ? this.diagnostics : []);
+            const state = parseState(file, activeStatePaths.has(file.displayPath) ? this.diagnostics : [], this.earliestBookmark);
+            if (state !== undefined && this.earliestBookmark !== undefined)
+                state.earliestBookmark = this.earliestBookmark;
             parsedStates.set(file.displayPath, state ?? null);
             if (state !== undefined) {
                 modelBudget.addDocument(state.document);
@@ -1075,9 +1185,8 @@ export class MapWorkspaceIndex {
         this.coastalProvinceIds = this.raster?.coastalProvinceIds ?? new Set();
         const portPositionsByStateProvince = new Map();
         for (const position of this.buildingPositions) {
-            if (position.building !== 'naval_base_spawn' && position.building !== 'floating_harbor') {
+            if (position.building !== 'naval_base_spawn')
                 continue;
-            }
             const provinceId = this.provinceAtMapCoordinate(position.x, position.z);
             if (provinceId === undefined)
                 continue;

package/dist/hoi4_agent_tools/map/operations.js

@@ -5,7 +5,7 @@ import { ServiceError } from '../core/result.js';
 import { applyReplacements, assignments, encodeSource, parseLocalisation, parseClausewitz, } from '../core/source/index.js';
 import { rgbKey } from './bmp.js';
 import { MAP_MASK_CELL_LIMIT, MAP_POLYGON_WORK_LIMIT, MAP_SELECTED_OFFSET_BYTES, MAP_SELECTED_PIXEL_LIMIT, } from './limits.js';
-import { derivedStateCapital, encodeTextDocument, MapWorkspaceIndex, parseTextDocument, } from './model.js';
+import { derivedStateCapital, encodeTextDocument, MapWorkspaceIndex, parseMapDate, parseTextDocument, } from './model.js';
 function* cancellationCheckpoint(signal, iteration = 0, stride = 1) {
     if (iteration % stride !== 0)
         return;
@@ -1034,8 +1034,74 @@ function stateMembershipId(index, provinceId) {
     return states[0]?.id;
 }
 function commitState(changes, state, data, fields, operationId) {
+    assertDatedStateHistorySafe(state, fields, operationId);
     addChange(changes, state.file.relativePath, patchState(state, data, fields), operationId, 'text/plain');
 }
+function assertDatedStateHistorySafe(state, fields, operationId) {
+    if (state.historyBlock === undefined)
+        return;
+    for (const entry of assignments(state.historyBlock)) {
+        if (entry.value.type !== 'block')
+            continue;
+        const datedAt = parseMapDate(entry.key.value);
+        if (datedAt === undefined)
+            continue;
+        const keys = new Set(assignments(entry.value).map(({ key }) => key.value));
+        const applicable = state.earliestBookmark === undefined || datedAt <= state.earliestBookmark.ordinal;
+        const affected = [
+            ['owner', fields.owner === true && keys.has('owner') && applicable],
+            ['controller', fields.controller === true && keys.has('controller') && applicable],
+            [
+                'cores',
+                fields.cores === true &&
+                    (keys.has('add_core_of') || keys.has('remove_core_of')) &&
+                    applicable,
+            ],
+            [
+                'claims',
+                fields.claims === true &&
+                    (keys.has('add_claim_by') || keys.has('remove_claim_by')) &&
+                    applicable,
+            ],
+            [
+                'victoryPoints',
+                ((fields.victoryPoints === true && applicable) || fields.provinces === true) &&
+                    keys.has('victory_points'),
+            ],
+            [
+                'buildings',
+                ((fields.buildings === true && applicable) || fields.provinces === true) &&
+                    keys.has('buildings'),
+            ],
+        ];
+        const conflict = affected.find(([, selected]) => selected);
+        if (conflict === undefined)
+            continue;
+        throw new ServiceError('MAP_DATED_STATE_HISTORY_CONFLICT', `State ${state.id} has a dated ${conflict[0]} change that this map operation cannot safely rewrite`, {
+            operationId,
+            stateId: state.id,
+            field: conflict[0],
+            datedAt: entry.key.value,
+            earliestBookmark: state.earliestBookmark?.value ?? null,
+            sourcePath: state.file.displayPath,
+            sourceOffset: entry.start,
+        });
+    }
+}
+function assertNoDatedStateHistory(state, operationId) {
+    if (state.historyBlock === undefined)
+        return;
+    const dated = assignments(state.historyBlock).find((entry) => entry.value.type === 'block' && parseMapDate(entry.key.value) !== undefined);
+    if (dated === undefined)
+        return;
+    throw new ServiceError('MAP_DATED_STATE_DISTRIBUTION_UNSUPPORTED', `State ${state.id} has dated history that cannot be distributed to a new or merged state`, {
+        operationId,
+        stateId: state.id,
+        datedAt: dated.key.value,
+        sourcePath: state.file.displayPath,
+        sourceOffset: dated.start,
+    });
+}
 function commitRegion(changes, region, provinces, operationId) {
     addChange(changes, region.file.relativePath, patchRegion(region, provinces), operationId, 'text/plain');
 }
@@ -1219,6 +1285,7 @@ function* applySplitState(base, changes, allocations, operation, signal) {
     const source = index.statesById.get(sourceStateId);
     if (source === undefined)
         throw new ServiceError('MAP_STATE_NOT_FOUND', `State ${sourceStateId} does not exist`);
+    assertNoDatedStateHistory(source, operation.id);
     const selectedSet = new Set(selected);
     if (selected.length === 0 || selected.some((id) => !source.provinces.includes(id))) {
         throw new ServiceError('MAP_STATE_PROVINCE_SELECTION_INVALID', 'Every new-state province must belong to the source state');
@@ -1336,6 +1403,8 @@ function applyMergeStates(base, changes, operation) {
     if (target === undefined || sourceIds.length === 0 || sources.length !== sourceIds.length) {
         throw new ServiceError('MAP_STATE_SELECTION_INVALID', 'Merge target and source states must exist');
     }
+    for (const source of sources)
+        assertNoDatedStateHistory(source, operation.id);
     const regionIds = new Set([...target.provinces, ...sources.flatMap((state) => state.provinces)].map((id) => regionMembershipId(index, id)));
     if (regionIds.size !== 1)
         throw new ServiceError('MAP_STATE_REGION_DISTRIBUTION_CONFLICT', 'Merged states must share one strategic region');
@@ -1964,12 +2033,16 @@ function* applyUpdateProvinceDefinition(base, changes, operation, signal) {
         if (policy.ports === 'retain-if-valid') {
             for (const position of dependentPortPositions) {
                 const locatedProvince = index.provinceAtMapCoordinate(position.x, position.z);
-                if ((locatedProvince === source.id &&
-                    (targetType !== 'land' ||
-                        position.stateId !== projectedStateId ||
-                        !updated.coastal ||
-                        index.definitionsById.get(position.adjacentSeaProvince)?.type !== 'sea')) ||
-                    (position.adjacentSeaProvince === source.id && targetType !== 'sea'))
+                const incompatible = position.building === 'floating_harbor'
+                    ? (locatedProvince === source.id && targetType !== 'sea') ||
+                        (position.adjacentSeaProvince === source.id && targetType !== 'land')
+                    : (locatedProvince === source.id &&
+                        (targetType !== 'land' ||
+                            position.stateId !== projectedStateId ||
+                            !updated.coastal ||
+                            index.definitionsById.get(position.adjacentSeaProvince)?.type !== 'sea')) ||
+                        (position.adjacentSeaProvince === source.id && targetType !== 'sea');
+                if (incompatible)
                     provinceTypeDistributionConflict(source, targetType, 'ports', 'A retained port placement would no longer identify compatible land and sea provinces', {
                         stateId: position.stateId,
                         locatedProvince: locatedProvince ?? null,

package/dist/hoi4_agent_tools/map/service.js

@@ -379,6 +379,7 @@ function defaultMapPatterns(roots) {
 }
 function sourceTextPatterns(roots) {
     return [
+        'common/bookmarks/**/*.txt',
         ...roots.map.flatMap((root) => {
             const normalized = normalizeSourceRoot(root);
             return ['map', 'csv', 'txt'].map((extension) => `${normalized}/**/*.${extension}`);