hoi4-agent-tools 4.4.0 → 4.6.0

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 # Changelog
 
+## 4.6.0 - 2026-10-25
+
+- Add the territory assignment service (ADR 0060). `assign_territory` grows up to 512 countries over the states or provinces of a map from capital and anchor seeds (state, province or pixel) with forced and blocked land, preferred strategic regions, subjects inside an overlord, merges, island policies, size targets by weight, extra cores and claims, and writes owner, controller, cores and claims. Borders follow rivers, ranges, lake shores and terrain changes (a shortest-path growth with barrier-weighted steps, size balancing, a corridor for cut-off seeds and a local search that shortens the artificial border); the result reports sizes against targets and the same seeds grown on distance alone. With `unit: "province"` the states a border cuts are regrouped in one pass, conserving population, resources and buildings exactly. `repartition_states` regroups the states of chosen owners along natural lines, and `update_states` edits up to 5,000 states in one rewrite. New diagnostics `MAP_TERRITORY_*`.
+- Land listed in `assign_territory.unowned`, and landmasses without a seed under `islandPolicy: "unowned"`, lose their owner (and controller) with `ownership.unowned: "clear"`, the default, or keep it with `"keep"`; states outside `scope` are never edited. Refusals name the state or province of the request (`MAP_TERRITORY_SEED_UNAVAILABLE`, `_FORCED_BLOCKED`, `_FORCED_CONFLICT`, `_FORCED_UNREACHABLE` carry `stateId` or `provinceId`). Results of a territory operation add `data.territory`.
+- Add `borderQuality` (`off`, `report`, `enforce`) and `borderTargets` to the territory operations and to `create_world` (G-58). The border naturalness of the proposed map is measured after the whole request and reported (`MAP_BORDER_QUALITY_MEASURED`, artifact `map-territory-report.json`); `enforce` blocks the write below the targets (`MAP_TERRITORY_BORDER_ARTIFICIAL`, `MAP_WORLD_BORDER_ARTIFICIAL`) and is refused for the legacy partition.
+- A feature-aware `create_world` without a reference picture now grows its generated countries along natural lines instead of blind breadth-first growth; legacy worlds are byte-identical, and workspace-owned countries (`countries.source: "workspace"`) keep the realm growth of ADR 0069.
+- Public schema change: new operation kinds `assign_territory`, `repartition_states` and `update_states` and new optional fields `borderQuality` and `borderTargets` on `create_world` (minor version at release; the schemas are regenerated).
+- Plan straits, passes and walls from a geography model (ADR 0062). A world built from a geography now writes each `strait` as a named `sea` row in `adjacencies.csv` with a rule in `adjacency_rules.txt` (`open`, `army-closed`, `navy-closed`), `impassable` rows for every pair of land provinces across a range with `barrier: "impassable"` except at its passes, land forts (`bunker`) at passes with a `fort` level, and sea provinces for a lake with `gameplay: "inland-sea"` with a canal row to the open sea. The partition now uses the model's regions, named seas and walls. New optional `create_world.autoStraits` (`true` or `{ maxGapPx }`). Diagnostics: `MAP_CROSSINGS_PLANNED`, `MAP_INLAND_SEA_CREATED`, `MAP_INLAND_SEA_SEALED`, `MAP_STRAIT_UNRESOLVED`, `MAP_STRAIT_DUPLICATE`, `MAP_STRAIT_NOT_NARROW`, `MAP_PASS_BLOCKED`, `MAP_RANGE_NOT_CLOSED` and the refusal `MAP_IMPASSABLE_ROW_LIMIT`. `hoi4.map_inspect` and every created world also check rules against rows and wall rows on any map: `MAP_ADJACENCY_RULE_MISSING`, `_DUPLICATE`, `_INVALID`, `_UNUSED`, `MAP_IMPASSABLE_NOT_ADJACENT`, `MAP_IMPASSABLE_NOT_LAND`, `MAP_ADJACENCY_ROW_LIMIT`, `MAP_RAILWAY_CROSSES_IMPASSABLE`, `MAP_UNIT_POSITION_MISSING`; thresholds are set so the installed game raises nothing above information. Worlds without a geography are unchanged.
+- Plan ports, development, names and railways from a geography model (ADR 0063). Ports follow a harbour score (concavity, shelter, river mouth, depth class, sites) with levels from site importance; population, category, infrastructure, factories, resources (ranges, `mine` sites, jungle) and victory points follow fertility, rivers, coast, passes and sites with no random rolls; states, strategic regions, victory points and lake provinces are named from sites, lakes, rivers, ranges, regions, lands and seas by containment, with counted placeholders (`MAP_NAME_PLACEHOLDER`); railways use a terrain-aware cost (ground, climb, rivers, gates, roads) and trunk lines of level 2 reach large cities. New optional `create_world.development: { model: "geography" | "legacy" }` (default `geography` for a geography world) and an optional `resource` on geography `mine` sites. Other diagnostics: `MAP_DEVELOPMENT_PLANNED`, `MAP_PORT_LAKE_UNSUPPORTED`, `MAP_PORT_SITE_NOT_COASTAL`, `MAP_SITE_UNPLACED`.
+- Accept a strait between two coasts of one land as a crossing between two provinces of that land when its straight line crosses water (`MAP_GEOGRAPHY_STRAIT_SAME_LAND` is then `info`; across no water it stays an error), and add `bay` as a sea `kind` of the geography model (ADR 0062). Public schema change: one more allowed value of `seas[].kind` (minor version).
+- Public schema change: new optional fields `development` and `autoStraits` on `create_world` and `resource` on geography sites (minor version at release; the schemas are regenerated; compatibility review: additive optional input only, no output field changed, behaviour changes only for worlds built from a geography).
+- Stop reporting the validation findings of a map that a failed `create_world` left in place: a world that cannot generate now returns only its own blockers, and a successful replacement of a map is validated on the map it produces instead of being compared with the map it replaces (ADR 0070). Before, a river that could not reach its mouth came back with three `MAP_VALIDATION_OPERATION_UNOWNED` blockers about the old map.
+- Let drawn rivers carve their valleys (ADR 0071). A river whose course crosses a divide higher than 22 height units (a volcano cone, a foothill, the tip of a range) is no longer refused: its bed is cut through the rise as a gorge, and each crossing is reported as the warning `MAP_RIVER_CARVED_CROSSING` with the river, climb and divide location (world pixel, height, nearest range or volcano). Models that were refused now write; models that wrote are unchanged.
+- Report every named river with an impossible course in one run: `MAP_RIVER_UNREACHABLE_MOUTH` (a mouth on another landmass, a source or via point that cannot be reached, a lake without a shore) keeps its code and top-level fields and gains `details.rivers`, each with its reason or `blockedBy` another failed river.
+- Add `create_world.synthesisCheck` (with `preview: true` and a geography): run only the relief and river synthesis and report all impossible rivers and carved crossings without writing (`MAP_SYNTHESIS_CHECK_READY`, `MAP_SYNTHESIS_CHECK_BLOCKED`, `data.synthesisCheck`). Public schema change: one new optional field on `create_world` (minor version).
+
+## 4.5.0 - 2026-10-25
+
+- Refuse `hoi4.focus_rewrite` with `FOCUS_SOURCE_CHANGED_SINCE_PLAN` when the focus source changed in meaning after the plan was inspected, instead of reverting the external change to the plan's values (national trees and continuous palettes). Comment and formatting changes and a source that already equals the plan are still accepted. Reported by the HOI4 Factory S01 EXP-02 probe.
+- Refuse every rewrite of a file that is not valid UTF-8 and contains bytes Windows-1252 cannot represent (0x81, 0x8D, 0x8F, 0x90, 0x9D) with `SOURCE_ENCODING_NOT_ROUND_TRIPPABLE`. Previously the encoder wrote 0x9D for each of them without a diagnostic. Reads and inspection continue and add a warning with the same code. Valid UTF-8 and valid Windows-1252 files are unchanged.
+- Place countries the mod already owns (ADR 0069): `create_world.countries` accepts `{ "source": "workspace", "realms": [...] }` besides the array. Each realm is a declared tag with a capital point and optional seeds, claim and exclusion polygons and a weight; `unowned` polygons and `islands` (`nearest`, `one-owner`, `unowned`) decide land no country claims. The world then writes only the map, states, strategic regions and their names, and none of the countries' files. New refusals `MAP_WORLD_REALM_TAG_UNKNOWN`, `MAP_WORLD_REALM_TAG_DYNAMIC`, `MAP_WORLD_REALM_POINT_OUTSIDE`, `MAP_WORLD_REALM_POINT_WATER`, `MAP_WORLD_REALM_POINT_CONFLICT` and `MAP_WORLD_REALM_CLAIM_OVERLAP`; notes `MAP_WORLD_REALMS_PLACED` and `MAP_WORLD_STATE_UNOWNED`; result field `data.realms` and artifact `map-world-realms.json`. Public schema change: `countries` becomes a union of the existing array and the new object (minor version). Requests with the array are unchanged.
+- Report what a world write does to the previous world's files: `MAP_WORLD_OUTPUTS_RECONCILED`, `data.outputs` (written, retired and released counts with up to 200 paths each) and the artifact `map-world-outputs.json`. With workspace countries an edited country file of the previous world is released to the mod (`MAP_WORLD_OUTPUT_RELEASED`) instead of refusing the write; every other edited output still refuses with `MANAGED_OUTPUT_EDITED`.
+- Report the declared country tags after every world write (`MAP_WORLD_TAG_COUNT`) and warn above 439 (`MAP_WORLD_TAG_COUNT_HIGH`), the count at which one measured game build overflowed its flag sheet.
+
 ## 4.4.0 - 2026-10-24
 
 - Collect test fixtures that a killed or crashed test run left in the temporary folder: the test setup now also sweeps `hoi4-*` fixtures that carry an owner record of a process that has ended (`sweepTemporaryDirectories` option `ownedFixturesOnly`). Unmarked folders and folders of a live process are never removed. Interrupted local runs had left 2,441 such folders (640 MB).

package/dist/hoi4_agent_tools/core/managed-outputs.js

@@ -16,6 +16,10 @@ const manifestSchema = z
     .strict();
 /** Pure planning only: the shared transaction engine performs every replacement and deletion. */
 export function reconcileManagedOutputs(input) {
+    return planManagedOutputs(input).changes;
+}
+/** Plans the managed-output reconciliation and reports what it writes, retires and releases. */
+export function planManagedOutputs(input) {
     const sources = new Map(input.sources
         .filter((f) => f.rootKind === 'mod')
         .map((f) => [f.relativePath.replaceAll('\\', '/').toLowerCase(), f]));
@@ -32,6 +36,9 @@ export function reconcileManagedOutputs(input) {
                 throw new ServiceError('MANAGED_OUTPUT_MANIFEST_INVALID', 'Generated-output inventory is invalid');
             }
         })();
+    const outputs = input.proposed.filter((f) => f.content !== null && input.permitsPath(f.relativePath));
+    const next = new Set(outputs.map((f) => f.relativePath.toLowerCase()));
+    const released = new Set();
     const seen = new Set();
     for (const file of previous) {
         const key = file.relativePath.toLowerCase();
@@ -43,19 +50,26 @@ export function reconcileManagedOutputs(input) {
             throw new ServiceError('MANAGED_OUTPUT_MANIFEST_INVALID', 'Generated-output inventory contains an unsupported or duplicate path');
         seen.add(key);
         const current = sources.get(key);
-        if (current !== undefined && sha256Bytes(current.bytes) !== file.sha256)
-            throw new ServiceError('MANAGED_OUTPUT_EDITED', 'A generated file has been edited; regeneration would discard those changes', { relativePath: file.relativePath });
+        if (current === undefined || sha256Bytes(current.bytes) === file.sha256)
+            continue;
+        if (!next.has(key) && input.releasable?.(file.relativePath) === true) {
+            released.add(key);
+            continue;
+        }
+        throw new ServiceError('MANAGED_OUTPUT_EDITED', 'A generated file has been edited; regeneration would discard those changes', { relativePath: file.relativePath });
     }
-    const outputs = input.proposed.filter((f) => f.content !== null && input.permitsPath(f.relativePath));
-    const next = new Set(outputs.map((f) => f.relativePath.toLowerCase()));
     const deletions = previous
-        .filter((f) => !next.has(f.relativePath.toLowerCase()) && sources.has(f.relativePath.toLowerCase()))
+        .filter((f) => {
+        const key = f.relativePath.toLowerCase();
+        return !next.has(key) && !released.has(key) && sources.has(key);
+    })
         .map((f) => ({
         relativePath: f.relativePath,
         content: null,
         operationIds: [input.operationId],
     }));
-    return [
+    const sorted = (paths) => [...paths].sort(compareCodeUnits);
+    const changes = [
         ...deletions,
         {
             relativePath: input.manifestPath,
@@ -69,4 +83,10 @@ export function reconcileManagedOutputs(input) {
             mediaType: 'application/json',
         },
     ];
+    return {
+        changes,
+        written: sorted(outputs.map((f) => f.relativePath)),
+        retired: sorted(deletions.map((f) => f.relativePath)),
+        released: sorted(previous.filter((f) => released.has(f.relativePath.toLowerCase())).map((f) => f.relativePath)),
+    };
 }

package/dist/hoi4_agent_tools/core/source/encoding.js

@@ -1,6 +1,7 @@
 import iconv from 'iconv-lite';
 import { ServiceError } from '../result.js';
 const utf8Bom = Buffer.from([0xef, 0xbb, 0xbf]);
+const REPLACEMENT_CHARACTER = String.fromCharCode(0xfffd);
 function detectNewline(text) {
     const crlf = text.indexOf('\r\n');
     const lf = text.indexOf('\n');
@@ -22,10 +23,55 @@ function isUtf8(bytes) {
         return false;
     }
 }
+let windows1252RoundTrip;
+function windows1252Table() {
+    windows1252RoundTrip ??= Array.from({ length: 256 }, (_, value) => {
+        const original = Buffer.from([value]);
+        const decoded = iconv.decode(original, 'windows-1252');
+        return (decoded !== REPLACEMENT_CHARACTER && iconv.encode(decoded, 'windows-1252').equals(original));
+    });
+    return windows1252RoundTrip;
+}
+function findWindows1252Loss(bytes) {
+    const table = windows1252Table();
+    let count = 0;
+    let firstOffset = -1;
+    const seen = new Set();
+    for (let offset = 0; offset < bytes.length; offset += 1) {
+        const value = bytes[offset];
+        if (table[value])
+            continue;
+        if (firstOffset < 0)
+            firstOffset = offset;
+        count += 1;
+        seen.add(value);
+    }
+    if (count === 0)
+        return undefined;
+    return { count, firstOffset, byteValues: [...seen].sort((left, right) => left - right) };
+}
+/**
+ * Refuses a mutation of a decoded source that cannot be re-encoded to its original bytes.
+ * Reads of such a source continue to work; only writes are blocked.
+ */
+export function assertSourceEncodingPreserved(decoded, sourcePath) {
+    const loss = decoded.encodingLoss;
+    if (loss === undefined)
+        return;
+    const values = loss.byteValues.map((value) => `0x${value.toString(16).toUpperCase()}`);
+    throw new ServiceError('SOURCE_ENCODING_NOT_ROUND_TRIPPABLE', `Source is not valid UTF-8 and contains ${loss.count} byte(s) (${values.join(', ')}) that Windows-1252 cannot represent; editing it would silently rewrite them. Convert the file to UTF-8 or replace those bytes, then retry`, {
+        path: sourcePath,
+        encoding: decoded.encoding,
+        byteCount: loss.count,
+        byteValues: values,
+        firstByteOffset: loss.firstOffset,
+    });
+}
 export function decodeSource(input) {
     const bytes = Buffer.from(input);
     let encoding;
     let text;
+    let encodingLoss;
     if (bytes.subarray(0, 3).equals(utf8Bom)) {
         encoding = 'utf8-bom';
         text = bytes.subarray(3).toString('utf8');
@@ -37,16 +83,24 @@ export function decodeSource(input) {
     else {
         encoding = 'windows-1252';
         text = iconv.decode(bytes, 'windows-1252');
+        encodingLoss = findWindows1252Loss(bytes);
     }
-    return { encoding, text, bytes, newline: detectNewline(text) };
+    return {
+        encoding,
+        text,
+        bytes,
+        newline: detectNewline(text),
+        ...(encodingLoss === undefined ? {} : { encodingLoss }),
+    };
 }
 export function encodeSource(text, encoding) {
     if (encoding === 'utf8')
         return Buffer.from(text, 'utf8');
     if (encoding === 'utf8-bom')
         return Buffer.concat([utf8Bom, Buffer.from(text, 'utf8')]);
+    // U+FFFD is what undefined Windows-1252 bytes decode to; iconv-lite would write it back as 0x9D.
     const encoded = iconv.encode(text, 'windows-1252');
-    if (iconv.decode(encoded, 'windows-1252') !== text) {
+    if (text.includes(REPLACEMENT_CHARACTER) || iconv.decode(encoded, 'windows-1252') !== text) {
         throw new ServiceError('SOURCE_ENCODING_UNREPRESENTABLE', 'The edit introduces characters that cannot be represented in the source encoding', { encoding });
     }
     return encoded;

package/dist/hoi4_agent_tools/core/source/parser.js

@@ -2,7 +2,7 @@ import { hasBlockingDiagnostics } from '../diagnostics.js';
 import { ServiceError } from '../result.js';
 import { sha256Bytes } from '../canonical.js';
 import { sourceDocumentCacheKey, sourceDocuments } from './cache.js';
-import { decodeSource, encodeSource } from './encoding.js';
+import { assertSourceEncodingPreserved, decodeSource, encodeSource, } from './encoding.js';
 import { createSourceLineIndex, isTrivia, lexClausewitz, locationFor, } from './lexer.js';
 import { SOURCE_LINE_LIMIT, SOURCE_MAX_BYTES, SOURCE_MAX_NESTING, SourceDiagnosticCollector, } from './limits.js';
 function scalarValue(token) {
@@ -298,6 +298,20 @@ function parseClausewitzUncached(bytes, sourcePath) {
             sourceRevision: sha256Bytes(decoded.bytes),
         };
     }
+    const encodingLoss = decoded.encodingLoss;
+    if (encodingLoss !== undefined) {
+        diagnostics.add(() => ({
+            code: 'SOURCE_ENCODING_NOT_ROUND_TRIPPABLE',
+            severity: 'warning',
+            category: 'syntax',
+            message: 'Source is not valid UTF-8 and contains bytes that Windows-1252 cannot represent; it can be read but any rewrite is refused',
+            location: locationFor(sourcePath, lineIndex, encodingLoss.firstOffset, encodingLoss.firstOffset + 1),
+            details: {
+                byteCount: encodingLoss.count,
+                byteValues: encodingLoss.byteValues.map((value) => `0x${value.toString(16).toUpperCase()}`),
+            },
+        }));
+    }
     const lexed = lexClausewitz(decoded.text, sourcePath, { lineIndex, diagnostics });
     const parser = new Parser(lexed.tokens, decoded.text, sourcePath, lineIndex, diagnostics);
     const root = parser.parseRoot();
@@ -323,6 +337,7 @@ export function assertRewriteSafe(document) {
     }
 }
 export function encodeDocumentText(document, text) {
+    assertSourceEncodingPreserved(document, document.path);
     return encodeSource(text, document.encoding);
 }
 export function assignments(block, key) {

package/dist/hoi4_agent_tools/focus/drift.js

@@ -72,6 +72,40 @@ export function assertFocusPlanAuthority(drift, authority) {
         currentPlanHash: drift.currentPlanHash,
     });
 }
+/**
+ * True when the source changed in meaning after the plan was imported, so regenerating from the
+ * plan would overwrite those changes. A formatting-only change (the source still imports to the
+ * plan's original baseline), a source that already equals the plan, and an unchanged source are not
+ * semantic drift. This is deliberately independent of whether the plan itself was edited: a plan
+ * edit plus an external formatting change reports `conflict`, which is still safe to apply.
+ */
+export function hasSemanticSourceDrift(drift) {
+    if (!drift.sourceChanged)
+        return false;
+    if (drift.status === 'tree_removed')
+        return true;
+    return (drift.currentPlanHash !== drift.importedPlanHash &&
+        drift.currentPlanHash !== drift.savedPlanHash);
+}
+/**
+ * Refuses to regenerate a tree from a plan when the source changed in meaning after the plan was
+ * imported. Applying the plan would overwrite those external changes with stale plan values.
+ * Re-import the source with the inspect tool, reapply the intended change to the fresh plan, and
+ * retry.
+ */
+export function assertNoSemanticSourceDrift(drift, sourcePath) {
+    if (!hasSemanticSourceDrift(drift))
+        return;
+    throw new ServiceError('FOCUS_SOURCE_CHANGED_SINCE_PLAN', 'The focus source changed in meaning after the plan was imported; rewriting from the plan would overwrite those changes. Import the current source with hoi4.focus_inspect, reapply the intended edit to the fresh plan, and retry', {
+        relativePath: sourcePath,
+        status: drift.status,
+        savedSourceHash: drift.savedSourceHash,
+        currentSourceHash: drift.currentSourceHash,
+        savedPlanHash: drift.savedPlanHash,
+        currentPlanHash: drift.currentPlanHash,
+        importedPlanHash: drift.importedPlanHash,
+    });
+}
 export function detectContinuousFocusDrift(savedPlan, currentDocument) {
     const currentSourceHash = sha256Bytes(currentDocument.bytes);
     const savedPlanHash = focusPlanHash(savedPlan);

package/dist/hoi4_agent_tools/focus/service.js

@@ -5,7 +5,7 @@ import { ServiceError } from '../core/result.js';
 import { parseClausewitz } from '../core/source/index.js';
 import { TRANSACTION_MAX_DIAGNOSTICS } from '../core/transaction-limits.js';
 import { PACKAGE_VERSION } from '../version.js';
-import { assertFocusPlanAuthority, detectContinuousFocusDrift, detectFocusDrift, } from './drift.js';
+import { assertFocusPlanAuthority, assertNoSemanticSourceDrift, detectContinuousFocusDrift, detectFocusDrift, } from './drift.js';
 import { importContinuousFocusPalettes, importFocusTrees } from './importer.js';
 import { layoutFocusTree, layoutFocusTreeAsync } from './layout.js';
 import { lintContinuousFocusPalette, lintFocusTree } from './lint.js';
@@ -191,8 +191,11 @@ export class FocusWorkbench {
         const drift = targetCreated
             ? missingTargetDrift(input.plan, document)
             : detectFocusDrift(input.plan, document, input.references);
-        if (!targetCreated)
+        if (!targetCreated) {
+            if (input.onSemanticSourceDrift === 'refuse')
+                assertNoSemanticSourceDrift(drift, input.relativePath);
             assertFocusPlanAuthority(drift, input.authority ?? 'plan');
+        }
         const layout = input.layout ??
             (await layoutFocusTreeAsync(input.plan, input.signal === undefined ? {} : { signal: input.signal }));
         const after = updateFocusTreeSource(document, targetCreated ? undefined : drift.currentSourcePlan, input.plan, layout);
@@ -414,8 +417,11 @@ export class FocusWorkbench {
         const drift = targetCreated
             ? missingTargetDrift(input.plan, document)
             : detectContinuousFocusDrift(input.plan, document);
-        if (!targetCreated)
+        if (!targetCreated) {
+            if (input.onSemanticSourceDrift === 'refuse')
+                assertNoSemanticSourceDrift(drift, input.relativePath);
             assertFocusPlanAuthority(drift, input.authority ?? 'plan');
+        }
         const after = updateContinuousFocusPaletteSource(document, targetCreated ? undefined : drift.currentSourcePlan, input.plan);
         const afterHash = sha256Bytes(after);
         const operationId = deterministicId('continuous_focus_change', {

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

@@ -147,6 +147,7 @@ export async function prepareFocusRewrite(engine, workbench, input, context) {
             plan,
             createIfMissing,
             authority: 'plan',
+            onSemanticSourceDrift: 'refuse',
             ...(context.principal === undefined ? {} : { principal: context.principal }),
             artifacts: reviewArtifacts,
             readDependencies: readDependenciesFromScannedFiles(snapshot.files),
@@ -301,6 +302,7 @@ export async function prepareFocusRewrite(engine, workbench, input, context) {
         plan,
         createIfMissing,
         authority: 'plan',
+        onSemanticSourceDrift: 'refuse',
         layout: proposed.layout,
         ...(context.principal === undefined ? {} : { principal: context.principal }),
         index: snapshot.index,

package/dist/hoi4_agent_tools/map/border-quality.js

@@ -25,9 +25,11 @@ export const BORDER_FEATURE_BITS = {
 };
 const BORDER_FEATURES = Object.keys(BORDER_FEATURE_BITS);
 /** Barrier set: the plan's measurement (rivers, steep gradients) plus lake shores and extras. */
-const BARRIER_MASK = 1 | 2 | 4 | 16;
+export const BORDER_BARRIER_MASK = 1 | 2 | 4 | 16;
+const BARRIER_MASK = BORDER_BARRIER_MASK;
 /** Natural set: the barrier set plus terrain-class changes. */
-const NATURAL_MASK = 31;
+export const BORDER_NATURAL_MASK = 31;
+const NATURAL_MASK = BORDER_NATURAL_MASK;
 /** Province kinds used by the metric. Only land provinces have land borders. */
 export const BORDER_PROVINCE_KIND = { unknown: 0, land: 1, sea: 2, lake: 3 };
 /** Targets for an engineered world: the design's thresholds, measured against vanilla. */
@@ -374,13 +376,16 @@ function validateInput(input) {
     if (planes.terrain !== undefined && planes.terrain.classes.length !== 256)
         throw new ServiceError('MAP_BORDER_QUALITY_INPUT_INVALID', 'The terrain class table needs 256 entries');
 }
-/** One streamed pass over the raster: collect every land border edge and the chance baseline. */
-export async function buildBorderEdgeTable(input, options = {}) {
+/**
+ * One streamed pass over the raster: collect every land border edge and the chance baseline. The
+ * pass is a generator that yields every 16 rows so a synchronous planner can interleave its own
+ * checkpoints; `buildBorderEdgeTable` drives it and yields to the event loop.
+ */
+export function* buildBorderEdgeTableSteps(input, options = {}) {
     const resolved = resolveOptions(options);
     validateInput(input);
     const { width, height, provinceIds, provinceKinds } = input;
     const rows = new FeatureRows(input, resolved);
-    const pace = new Pace(resolved.signal);
     let capacity = Math.min(65_536, resolved.maxEdges);
     let keys = new Int32Array(capacity);
     let provinceA = new Int32Array(capacity);
@@ -446,8 +451,10 @@ export async function buildBorderEdgeTable(input, options = {}) {
         }
     };
     for (let y = 0; y < height; y += 1) {
-        if (y % 16 === 0)
-            await pace.tick();
+        if (y % 16 === 0) {
+            resolved.signal?.throwIfAborted();
+            yield;
+        }
         if (y + 1 < height)
             rows.rowFlags(y + 1, next);
         const rowStart = y * width;
@@ -506,6 +513,17 @@ export async function buildBorderEdgeTable(input, options = {}) {
         options: resolved,
     };
 }
+/** Drive `buildBorderEdgeTableSteps`, yielding to the event loop about every 12 milliseconds. */
+export async function buildBorderEdgeTable(input, options = {}) {
+    const steps = buildBorderEdgeTableSteps(input, options);
+    const pace = new Pace(options.signal);
+    for (;;) {
+        const step = steps.next();
+        if (step.done)
+            return step.value;
+        await pace.tick();
+    }
+}
 function round(value, places = 4) {
     const scale = 10 ** places;
     return Math.round(value * scale) / scale;

package/dist/hoi4_agent_tools/map/derived.js

@@ -623,7 +623,7 @@ function shortestRailPath(neighbors, sources, isTarget, cost) {
             return path;
         }
         for (const next of neighbors(province)) {
-            const candidate = current + cost(next);
+            const candidate = current + cost(province, next);
             if (candidate < (distance.get(next) ?? Number.POSITIVE_INFINITY)) {
                 distance.set(next, candidate);
                 previous.set(next, province);
@@ -726,12 +726,25 @@ export function planSupplyRebuild(index, request) {
         const pending = new Set(ownerScope
             .map((state) => state.provinces.find((id) => nodes.has(id)))
             .filter((id) => id !== undefined && !connected.has(id)));
+        // Trunk lines reach the major cities of the country even where no supply node stands.
+        const trunk = new Set();
+        for (const id of request.railCost?.trunk ?? [])
+            if (ownerOf(id) === owner && !connected.has(id) && neighbors(id).length > 0) {
+                trunk.add(id);
+                pending.add(id);
+            }
+        const ownerFactor = (id) => (ownerOf(id) === owner ? 1 : 4);
+        const stepCost = (from, to) => (request.railCost?.cost(from, to) ?? 1) * ownerFactor(to);
         while (pending.size > 0) {
-            const path = shortestRailPath(neighbors, connected, (id) => pending.has(id), (id) => (ownerOf(id) === owner ? 1 : 4));
+            const path = shortestRailPath(neighbors, connected, (id) => pending.has(id), stepCost);
             if (path === undefined)
                 break;
             // A path that leaves the connected set once: from its target back to the network.
-            const level = path.includes(hub) ? capitalLevel : railwayLevel;
+            const level = path.includes(hub)
+                ? capitalLevel
+                : trunk.has(path[0])
+                    ? Math.max(railwayLevel, request.trunkRailwayLevel ?? 2)
+                    : railwayLevel;
             newRailways.push({ level, provinces: [...path].reverse() });
             railways.push(path);
             for (const id of path) {