hoi4-agent-tools 3.3.0 → 3.4.1

package/dist/hoi4_agent_tools/focus/compact.js

@@ -226,18 +226,155 @@ function straightenLinearChains(plan, preferredX, preferredY) {
         preferredY.set(focus.id, parentY + 1);
     }
 }
-function compactCandidate(plan, layout, strategy) {
+function validatedSelection(plan, selection) {
+    if (selection.focusIds?.length === 0)
+        throw new ServiceError('FOCUS_COMPACT_SELECTION_EMPTY', 'Compact focus selection requires at least one focus');
+    const known = new Set(plan.focuses.map(({ id }) => id));
+    for (const id of [...(selection.focusIds ?? []), ...(selection.pinnedFocusIds ?? [])])
+        if (!known.has(id))
+            throw new ServiceError('FOCUS_COMPACT_SELECTION_UNKNOWN', 'Compact focus selection names an unknown focus', { treeId: plan.id, focusId: id });
+    const used = new Set();
+    for (const group of selection.symmetryGroups ?? []) {
+        if (!known.has(group.centerFocusId))
+            throw new ServiceError('FOCUS_COMPACT_SYMMETRY_UNKNOWN', 'Symmetry center is unknown', {
+                treeId: plan.id,
+                focusId: group.centerFocusId,
+            });
+        for (const pair of group.pairs) {
+            for (const id of [pair.leftFocusId, pair.rightFocusId]) {
+                if (!known.has(id))
+                    throw new ServiceError('FOCUS_COMPACT_SYMMETRY_UNKNOWN', 'Symmetry focus is unknown', {
+                        treeId: plan.id,
+                        focusId: id,
+                    });
+                if (id === group.centerFocusId || used.has(id))
+                    throw new ServiceError('FOCUS_COMPACT_SYMMETRY_DUPLICATE', 'A symmetry focus must belong to one pair and differ from its center', { treeId: plan.id, focusId: id });
+                used.add(id);
+            }
+        }
+    }
+    return {
+        ...(selection.focusIds === undefined ? {} : { focusIds: new Set(selection.focusIds) }),
+        pinnedFocusIds: new Set(selection.pinnedFocusIds ?? []),
+        symmetryGroups: selection.symmetryGroups ?? [],
+    };
+}
+function symmetryViolations(layout, groups) {
+    const positions = new Map(layout.nodes.map(({ id, x, y }) => [id, { x, y }]));
+    return groups.flatMap(({ centerFocusId, pairs }) => {
+        const center = positions.get(centerFocusId);
+        if (center === undefined)
+            return [];
+        return pairs.flatMap(({ leftFocusId, rightFocusId }) => {
+            const left = positions.get(leftFocusId);
+            const right = positions.get(rightFocusId);
+            if (left === undefined || right === undefined)
+                return [];
+            const xOffset = left.x + right.x - 2 * center.x;
+            const yOffset = left.y - right.y;
+            return Math.abs(xOffset) <= 1 && yOffset === 0
+                ? []
+                : [{ centerFocusId, leftFocusId, rightFocusId, xOffset, yOffset }];
+        });
+    });
+}
+function applySymmetryGroups(selection, layout, preferredX, preferredY) {
+    const original = new Map(layout.nodes.map(({ id, x, y }) => [id, { x, y }]));
+    const fixed = (id) => selection.pinnedFocusIds.has(id) || selection.focusIds?.has(id) === false;
+    for (const { centerFocusId, pairs } of selection.symmetryGroups) {
+        const centerX = fixed(centerFocusId)
+            ? original.get(centerFocusId)?.x
+            : preferredX.get(centerFocusId);
+        if (centerX === undefined)
+            continue;
+        for (const { leftFocusId, rightFocusId } of pairs) {
+            const leftFixed = fixed(leftFocusId);
+            const rightFixed = fixed(rightFocusId);
+            const leftX = leftFixed ? original.get(leftFocusId)?.x : preferredX.get(leftFocusId);
+            const rightX = rightFixed ? original.get(rightFocusId)?.x : preferredX.get(rightFocusId);
+            if (leftX === undefined || rightX === undefined)
+                continue;
+            if (!leftFixed && !rightFixed) {
+                const distance = Math.max(1, Math.round((rightX - leftX) / 2));
+                preferredX.set(leftFocusId, centerX - distance);
+                preferredX.set(rightFocusId, centerX + distance);
+            }
+            else if (!leftFixed)
+                preferredX.set(leftFocusId, 2 * centerX - rightX);
+            else if (!rightFixed)
+                preferredX.set(rightFocusId, 2 * centerX - leftX);
+            const leftY = leftFixed ? original.get(leftFocusId)?.y : preferredY.get(leftFocusId);
+            const rightY = rightFixed ? original.get(rightFocusId)?.y : preferredY.get(rightFocusId);
+            if (leftY === undefined || rightY === undefined)
+                continue;
+            const row = leftFixed ? leftY : rightFixed ? rightY : Math.round((leftY + rightY) / 2);
+            if (!leftFixed)
+                preferredY.set(leftFocusId, row);
+            if (!rightFixed)
+                preferredY.set(rightFocusId, row);
+        }
+    }
+}
+function scopedPrevious(current, focusIds) {
+    return { ...current, nodes: current.nodes.filter(({ id }) => !focusIds.has(id)) };
+}
+function movedOutsideSelection(current, proposed, focusIds, pinnedFocusIds) {
+    const fixed = new Set([
+        ...current.nodes.filter(({ id }) => focusIds?.has(id) === false).map(({ id }) => id),
+        ...pinnedFocusIds,
+    ]);
+    const before = new Map(current.nodes.map(({ id, x, y }) => [id, { x, y }]));
+    return proposed.nodes
+        .filter(({ id, x, y }) => {
+        const original = before.get(id);
+        return fixed.has(id) && (original?.x !== x || original.y !== y);
+    })
+        .map(({ id }) => id)
+        .sort(compareCodeUnits);
+}
+function relativeCompactRegressions(current, proposed) {
+    const before = requiredMetrics(current);
+    const after = requiredMetrics(proposed);
+    const hard = (layout) => layout.diagnostics.filter(({ code }) => COMPACT_HARD_DIAGNOSTICS.has(code)).length;
+    return [
+        ...(hard(proposed) > hard(current) ? ['hardLayoutDiagnostics'] : []),
+        ...(after.connectors.crossingCount > before.connectors.crossingCount
+            ? ['connectorCrossingCount']
+            : []),
+        ...(after.connectors.nodeIntersectionCount > before.connectors.nodeIntersectionCount
+            ? ['connectorNodeIntersections']
+            : []),
+        ...(after.spacing.tooCloseSameRowPairCount > before.spacing.tooCloseSameRowPairCount
+            ? ['sameRowSpacing']
+            : []),
+    ];
+}
+function compactCandidate(plan, layout, strategy, selection = {
+    pinnedFocusIds: new Set(),
+    symmetryGroups: [],
+}) {
     const { scale, compressRows, structuralRows: useStructuralRows, mirrorSiblings, straightenChains, } = strategy;
-    const minimumX = Math.min(...layout.nodes.map(({ x }) => x));
-    const maximumX = Math.max(...layout.nodes.map(({ x }) => x));
-    const minimumY = Math.min(...layout.nodes.map(({ y }) => y));
+    const scopeNodes = selection.focusIds === undefined
+        ? layout.nodes
+        : layout.nodes.filter(({ id }) => selection.focusIds.has(id));
+    const minimumX = Math.min(...scopeNodes.map(({ x }) => x));
+    const maximumX = Math.max(...scopeNodes.map(({ x }) => x));
+    const minimumY = Math.min(...scopeNodes.map(({ y }) => y));
     const centerX = (minimumX + maximumX) / 2;
-    const preferredX = new Map(layout.nodes.map((node) => [node.id, Math.round((node.x - centerX) * scale)]));
-    const sourceRows = [...new Set(layout.nodes.map(({ y }) => y))].sort((left, right) => left - right);
+    const preferredX = new Map(layout.nodes.map((node) => [
+        node.id,
+        Math.round((node.x - centerX) * scale + (selection.focusIds === undefined ? 0 : centerX)),
+    ]));
+    const sourceRows = [...new Set(scopeNodes.map(({ y }) => y))].sort((left, right) => left - right);
     const compactRows = new Map(sourceRows.map((row, index) => [row, index]));
     const preferredY = new Map(layout.nodes.map((node) => [
         node.id,
-        compressRows ? (compactRows.get(node.y) ?? node.y - minimumY) : node.y - minimumY,
+        compressRows
+            ? (compactRows.get(node.y) ?? node.y - minimumY) +
+                (selection.focusIds === undefined ? 0 : minimumY)
+            : selection.focusIds === undefined
+                ? node.y - minimumY
+                : node.y,
     ]));
     if (useStructuralRows) {
         const normalizedRows = structuralRows(plan);
@@ -270,13 +407,28 @@ function compactCandidate(plan, layout, strategy) {
         mirrorSiblingCohorts(plan, preferredX, preferredY);
     if (straightenChains)
         straightenLinearChains(plan, preferredX, preferredY);
+    applySymmetryGroups(selection, layout, preferredX, preferredY);
     const compacted = structuredClone(plan);
-    compacted.laneGroups = compacted.laneGroups.map(({ id, label, order }) => ({
-        id,
-        label,
-        order,
-    }));
+    if (selection.focusIds === undefined)
+        compacted.laneGroups = compacted.laneGroups.map(({ id, label, order }) => ({
+            id,
+            label,
+            order,
+        }));
+    const currentCoordinates = new Map(layout.nodes.map(({ id, x, y }) => [id, { x, y }]));
     for (const focus of compacted.focuses) {
+        if (selection.focusIds !== undefined && !selection.focusIds.has(focus.id))
+            continue;
+        if (selection.pinnedFocusIds.has(focus.id)) {
+            if (focus.position.mode === 'auto') {
+                const point = currentCoordinates.get(focus.id);
+                if (point !== undefined)
+                    focus.position = { mode: 'fixed', ...point, pinned: true };
+            }
+            else
+                focus.position = { ...focus.position, pinned: true };
+            continue;
+        }
         focus.position = {
             mode: 'auto',
             pinned: false,
@@ -390,7 +542,8 @@ function needsPresentationNormalization(plan) {
  * repair and compression candidates are measured with the same layout engine.
  * Invalid geometry cannot win; aesthetic tradeoffs are resolved by the score.
  */
-export function compactFocusTreePlan(plan) {
+export function compactFocusTreePlan(plan, requested = {}) {
+    const selection = validatedSelection(plan, requested);
     const currentLayout = layoutFocusTree(plan, { aggressiveAestheticRepair: true });
     const normalizedPlan = needsPresentationNormalization(plan)
         ? compactCandidate(plan, currentLayout, {
@@ -399,27 +552,51 @@ export function compactFocusTreePlan(plan) {
             structuralRows: false,
             mirrorSiblings: false,
             straightenChains: false,
-        })
+        }, selection)
         : plan;
     const normalizedLayout = normalizedPlan === plan
         ? currentLayout
-        : layoutFocusTree(normalizedPlan, { aggressiveAestheticRepair: true });
+        : layoutFocusTree(normalizedPlan, {
+            aggressiveAestheticRepair: true,
+            ...(selection.focusIds === undefined
+                ? {}
+                : { previous: scopedPrevious(currentLayout, selection.focusIds) }),
+        });
     let selected;
     let fallback;
+    const blockedFocusIds = new Set();
+    let blockedSymmetry = [];
     for (const strategy of compactStrategies(plan.focuses.length)) {
-        const candidate = compactCandidate(normalizedPlan, normalizedLayout, strategy);
+        const candidate = compactCandidate(normalizedPlan, normalizedLayout, strategy, selection);
         let layout;
         try {
-            layout = layoutFocusTree(candidate, { aggressiveAestheticRepair: true });
+            layout = layoutFocusTree(candidate, {
+                aggressiveAestheticRepair: true,
+                ...(selection.focusIds === undefined
+                    ? {}
+                    : { previous: scopedPrevious(currentLayout, selection.focusIds) }),
+            });
         }
         catch (error) {
             if (error instanceof ServiceError && error.code === 'FOCUS_LAYOUT_WORK_BUDGET_BLOCKED')
                 continue;
             throw error;
         }
+        const moved = movedOutsideSelection(currentLayout, layout, selection.focusIds, selection.pinnedFocusIds);
+        for (const id of moved)
+            blockedFocusIds.add(id);
+        if (moved.length > 0)
+            continue;
+        const symmetry = symmetryViolations(layout, selection.symmetryGroups);
+        if (symmetry.length > 0) {
+            blockedSymmetry = symmetry;
+            continue;
+        }
         if (fallback === undefined || betterScore(compactScore(layout), compactScore(fallback.layout)))
             fallback = { plan: candidate, layout };
-        if (absoluteCompactRegressions(layout).length > 0)
+        if ((selection.focusIds === undefined
+            ? absoluteCompactRegressions(layout)
+            : relativeCompactRegressions(currentLayout, layout)).length > 0)
             continue;
         if (selected === undefined || betterScore(compactScore(layout), compactScore(selected.layout)))
             selected = { plan: candidate, layout };
@@ -427,9 +604,13 @@ export function compactFocusTreePlan(plan) {
     if (selected !== undefined)
         return selected.plan;
     if (fallback !== undefined) {
-        assertCompactLayoutQuality(currentLayout, fallback.layout);
+        assertCompactLayoutQuality(currentLayout, fallback.layout, selection.focusIds !== undefined);
         return fallback.plan;
     }
+    if (blockedFocusIds.size > 0)
+        throw new ServiceError('FOCUS_COMPACT_ANCHOR_CONFLICT', 'No compact candidate preserves the selected branch boundary and pinned anchors', { treeId: plan.id, movedFocusIds: [...blockedFocusIds].sort(compareCodeUnits) });
+    if (blockedSymmetry.length > 0)
+        throw new ServiceError('FOCUS_COMPACT_SYMMETRY_CONFLICT', 'No compact candidate satisfies the requested symmetry pairs', { treeId: plan.id, pairs: blockedSymmetry });
     throw new ServiceError('FOCUS_COMPACT_LAYOUT_REQUIRED', 'Compact focus planning did not produce a measurable layout candidate', { treeId: plan.id });
 }
 /**
@@ -437,6 +618,7 @@ export function compactFocusTreePlan(plan) {
  * one work budget, and the selected layout is returned for validation/rendering.
  */
 export async function compactFocusTreePlanAsync(plan, options = {}) {
+    const selection = validatedSelection(plan, options);
     const workBudget = new FocusLayoutWorkBudget(options.maximumWork ?? COMPACT_LAYOUT_WORK_MAX);
     const layoutOptions = {
         workBudget,
@@ -451,20 +633,32 @@ export async function compactFocusTreePlanAsync(plan, options = {}) {
             structuralRows: false,
             mirrorSiblings: false,
             straightenChains: false,
-        })
+        }, selection)
         : plan;
     const normalizedLayout = normalizedPlan === plan
         ? currentLayout
-        : await layoutFocusTreeAsync(normalizedPlan, layoutOptions);
+        : await layoutFocusTreeAsync(normalizedPlan, {
+            ...layoutOptions,
+            ...(selection.focusIds === undefined
+                ? {}
+                : { previous: scopedPrevious(currentLayout, selection.focusIds) }),
+        });
     let selected;
     let fallback;
     let exhausted;
+    const blockedFocusIds = new Set();
+    let blockedSymmetry = [];
     candidateSearch: for (const strategy of compactStrategies(plan.focuses.length)) {
         options.signal?.throwIfAborted();
-        const candidate = compactCandidate(normalizedPlan, normalizedLayout, strategy);
+        const candidate = compactCandidate(normalizedPlan, normalizedLayout, strategy, selection);
         let layout;
         try {
-            layout = await layoutFocusTreeAsync(candidate, layoutOptions);
+            layout = await layoutFocusTreeAsync(candidate, {
+                ...layoutOptions,
+                ...(selection.focusIds === undefined
+                    ? {}
+                    : { previous: scopedPrevious(currentLayout, selection.focusIds) }),
+            });
         }
         catch (error) {
             if (error instanceof ServiceError && error.code === 'FOCUS_LAYOUT_WORK_BUDGET_BLOCKED') {
@@ -473,9 +667,21 @@ export async function compactFocusTreePlanAsync(plan, options = {}) {
             }
             throw error;
         }
+        const moved = movedOutsideSelection(currentLayout, layout, selection.focusIds, selection.pinnedFocusIds);
+        for (const id of moved)
+            blockedFocusIds.add(id);
+        if (moved.length > 0)
+            continue;
+        const symmetry = symmetryViolations(layout, selection.symmetryGroups);
+        if (symmetry.length > 0) {
+            blockedSymmetry = symmetry;
+            continue;
+        }
         if (fallback === undefined || betterScore(compactScore(layout), compactScore(fallback.layout)))
             fallback = { plan: candidate, layout };
-        if (absoluteCompactRegressions(layout).length > 0)
+        if ((selection.focusIds === undefined
+            ? absoluteCompactRegressions(layout)
+            : relativeCompactRegressions(currentLayout, layout)).length > 0)
             continue;
         if (selected === undefined || betterScore(compactScore(layout), compactScore(selected.layout)))
             selected = { plan: candidate, layout };
@@ -486,14 +692,22 @@ export async function compactFocusTreePlanAsync(plan, options = {}) {
     if (exhausted !== undefined)
         throw exhausted;
     if (fallback !== undefined) {
-        assertCompactLayoutQuality(currentLayout, fallback.layout);
+        assertCompactLayoutQuality(currentLayout, fallback.layout, selection.focusIds !== undefined);
         return { plan: fallback.plan, currentLayout, proposedLayout: fallback.layout };
     }
+    if (blockedFocusIds.size > 0)
+        throw new ServiceError('FOCUS_COMPACT_ANCHOR_CONFLICT', 'No compact candidate preserves the selected branch boundary and pinned anchors', { treeId: plan.id, movedFocusIds: [...blockedFocusIds].sort(compareCodeUnits) });
+    if (blockedSymmetry.length > 0)
+        throw new ServiceError('FOCUS_COMPACT_SYMMETRY_CONFLICT', 'No compact candidate satisfies the requested symmetry pairs', { treeId: plan.id, pairs: blockedSymmetry });
     throw new ServiceError('FOCUS_COMPACT_LAYOUT_REQUIRED', 'Compact focus planning did not produce a measurable layout candidate', { treeId: plan.id });
 }
 /** Refuses compact rewrites that still contain invalid or unreadable geometry. */
-export function assertCompactLayoutQuality(_current, proposed) {
-    const regressions = [...absoluteCompactRegressions(proposed)].filter((value, index, all) => all.indexOf(value) === index);
+export function assertCompactLayoutQuality(_current, proposed, relativeToBaseline = false) {
+    const regressions = [
+        ...(relativeToBaseline && _current !== undefined
+            ? relativeCompactRegressions(_current, proposed)
+            : absoluteCompactRegressions(proposed)),
+    ].filter((value, index, all) => all.indexOf(value) === index);
     if (regressions.length === 0)
         return;
     throw new ServiceError('FOCUS_COMPACT_QUALITY_BLOCKED', 'Compact focus reflow failed the layout-correctness gate', {

package/dist/hoi4_agent_tools/focus/layout.js

@@ -3,7 +3,7 @@ import { compareCodeUnits, hashCanonical } from '../core/canonical.js';
 import { DiagnosticCollector } from '../core/diagnostic-collector.js';
 import { sortDiagnostics } from '../core/diagnostics.js';
 import { ServiceError } from '../core/result.js';
-import { flattenFocusConnectorCurve, focusConnectorCurve, focusConnectorPolylinesIntersect, focusConnectorPolylineIntersectsRectangle, focusNodeRectangle, focusNodesVisiblyOverlap, } from './geometry.js';
+import { flattenFocusConnectorCurve, focusConnectorCurve, focusConnectorPolylinesIntersect, focusConnectorPolylineIntersectsRectangle, focusNodeRectangle, focusNodesVisiblyOverlap, FOCUS_HORIZONTAL_GRID_PIXELS, FOCUS_NODE_HEIGHT_PIXELS, FOCUS_NODE_WIDTH_PIXELS, FOCUS_VERTICAL_GRID_PIXELS, } from './geometry.js';
 import { FOCUS_GRAPH_MAX_DEPTH, FOCUS_DIAGNOSTIC_MAX, FOCUS_GRAPH_MAX_EDGES, FOCUS_GRAPH_MAX_NODES, FOCUS_LAYOUT_WORK_MAX, } from './limits.js';
 import {} from './model.js';
 export class FocusLayoutWorkBudget {
@@ -264,14 +264,61 @@ function* connectorCrossings(edges, context) {
         edge,
         points: flattenFocusConnectorCurve(focusConnectorCurve(edge.parent, edge.child)),
     }));
+    // Most focus connectors span one or two grid rows. Index those rows so
+    // unrelated branches do not consume the fixed work budget as an E² scan.
+    const maximumBucketSpan = 64;
+    const byRow = new Map();
+    const longEdges = [];
+    const intervals = edges.map(({ parent, child }) => ({
+        minimum: Math.min(parent.y, child.y),
+        maximum: Math.max(parent.y, child.y),
+    }));
+    for (const [index, interval] of intervals.entries()) {
+        const span = interval.maximum - interval.minimum;
+        if (span <= 0)
+            continue;
+        if (!Number.isSafeInteger(interval.minimum) ||
+            !Number.isSafeInteger(span) ||
+            span > maximumBucketSpan) {
+            longEdges.push(index);
+            continue;
+        }
+        for (let row = interval.minimum; row < interval.maximum; row += 1) {
+            context.work.spend('connector row index');
+            const bucket = byRow.get(row) ?? [];
+            bucket.push(index);
+            byRow.set(row, bucket);
+        }
+    }
     let crossingCount = 0;
     for (let leftIndex = 0; leftIndex < flattened.length; leftIndex += 1) {
         yield* cancellationCheckpoint(context.signal, leftIndex, 16);
         const left = flattened[leftIndex];
         if (left === undefined)
             continue;
-        for (let rightIndex = leftIndex + 1; rightIndex < flattened.length; rightIndex += 1) {
-            yield* cancellationCheckpoint(context.signal, rightIndex - leftIndex, 64);
+        const interval = intervals[leftIndex];
+        const span = interval.maximum - interval.minimum;
+        if (span <= 0)
+            continue;
+        const candidates = new Set();
+        if (span > maximumBucketSpan ||
+            !Number.isSafeInteger(interval.minimum) ||
+            !Number.isSafeInteger(span)) {
+            for (let index = leftIndex + 1; index < edges.length; index += 1)
+                candidates.add(index);
+        }
+        else {
+            for (let row = interval.minimum; row < interval.maximum; row += 1)
+                for (const index of byRow.get(row) ?? [])
+                    if (index > leftIndex)
+                        candidates.add(index);
+            for (const index of longEdges)
+                if (index > leftIndex)
+                    candidates.add(index);
+        }
+        const orderedCandidates = [...candidates].sort((leftIndex, rightIndex) => leftIndex - rightIndex);
+        for (const [candidateIndex, rightIndex] of orderedCandidates.entries()) {
+            yield* cancellationCheckpoint(context.signal, candidateIndex, 64);
             const right = edges[rightIndex];
             const rightFlattened = flattened[rightIndex];
             if (right === undefined || rightFlattened === undefined)
@@ -1062,15 +1109,33 @@ function* placeFocus(context, focusId, inheritedStack = new Set()) {
 }
 function* visibleOverlapDiagnostics(context) {
     const nodes = [...context.placed.values()].sort((left, right) => compareCodeUnits(left.id, right.id));
+    const cells = new Map();
+    for (const node of nodes) {
+        const key = `${Math.floor(node.x)},${Math.floor(node.y)}`;
+        const cell = cells.get(key) ?? [];
+        cell.push(node);
+        cells.set(key, cell);
+    }
     for (let leftIndex = 0; leftIndex < nodes.length; leftIndex += 1) {
         yield* cancellationCheckpoint(context.signal, leftIndex, 16);
         const left = nodes[leftIndex];
         if (left === undefined)
             continue;
-        for (let rightIndex = leftIndex + 1; rightIndex < nodes.length; rightIndex += 1) {
+        const candidates = [];
+        const cellX = Math.floor(left.x);
+        const cellY = Math.floor(left.y);
+        for (let y = cellY - 1; y <= cellY + 1; y += 1) {
+            for (let x = cellX - 1; x <= cellX + 1; x += 1) {
+                for (const candidate of cells.get(`${x},${y}`) ?? []) {
+                    if (compareCodeUnits(candidate.id, left.id) > 0)
+                        candidates.push(candidate);
+                }
+            }
+        }
+        candidates.sort((first, second) => compareCodeUnits(first.id, second.id));
+        for (const right of candidates) {
             context.work.spend('final visible-overlap comparison');
-            const right = nodes[rightIndex];
-            if (right === undefined || !focusNodesVisiblyOverlap(left, right))
+            if (!focusNodesVisiblyOverlap(left, right))
                 continue;
             const focus = context.focuses.get(right.id);
             context.diagnostics.push({
@@ -1189,12 +1254,44 @@ function* mutualExclusionSpacingDiagnostics(context) {
     }
 }
 function* connectorNodeIntersectionDiagnostics(context, edges) {
-    const nodes = [...context.placed.values()].sort((left, right) => compareCodeUnits(left.id, right.id));
+    const nodesByY = [...context.placed.values()].sort((left, right) => left.y - right.y || compareCodeUnits(left.id, right.id));
     let comparisonIndex = 0;
     let intersectionCount = 0;
     for (const edge of edges) {
         const flattened = flattenFocusConnectorCurve(focusConnectorCurve(edge.parent, edge.child));
-        for (const node of nodes) {
+        let minimumX = Infinity;
+        let maximumX = -Infinity;
+        let minimumY = Infinity;
+        let maximumY = -Infinity;
+        for (const point of flattened) {
+            minimumX = Math.min(minimumX, point.x);
+            maximumX = Math.max(maximumX, point.x);
+            minimumY = Math.min(minimumY, point.y);
+            maximumY = Math.max(maximumY, point.y);
+        }
+        const minimumNodeY = (minimumY - FOCUS_NODE_HEIGHT_PIXELS) / FOCUS_VERTICAL_GRID_PIXELS;
+        const maximumNodeY = maximumY / FOCUS_VERTICAL_GRID_PIXELS;
+        const minimumNodeX = (minimumX - FOCUS_NODE_WIDTH_PIXELS) / FOCUS_HORIZONTAL_GRID_PIXELS;
+        const maximumNodeX = maximumX / FOCUS_HORIZONTAL_GRID_PIXELS;
+        let low = 0;
+        let high = nodesByY.length;
+        while (low < high) {
+            const middle = Math.floor((low + high) / 2);
+            if (nodesByY[middle].y < minimumNodeY)
+                low = middle + 1;
+            else
+                high = middle;
+        }
+        const candidates = [];
+        for (let index = low; index < nodesByY.length; index += 1) {
+            const node = nodesByY[index];
+            if (node.y > maximumNodeY)
+                break;
+            if (node.x >= minimumNodeX && node.x <= maximumNodeX)
+                candidates.push(node);
+        }
+        candidates.sort((left, right) => compareCodeUnits(left.id, right.id));
+        for (const node of candidates) {
             yield* cancellationCheckpoint(context.signal, comparisonIndex, 32);
             comparisonIndex += 1;
             if (node.id === edge.parentId || node.id === edge.childId)
@@ -2196,6 +2293,20 @@ function* layoutFocusTreeSteps(plan, options = {}) {
         decisions,
         diagnostics: sortDiagnostics(context.diagnostics.values()),
         metrics: layoutMetrics(context, edges, crossingSummary.count, nodeIntersectionCount, symmetry, spacing),
+        connectorMeasurements: edges
+            .map((edge) => {
+            const spans = connectorSpans(edge);
+            return {
+                parentId: edge.parentId,
+                childId: edge.childId,
+                horizontalSpan: spans.horizontal,
+                verticalSpan: spans.vertical,
+                manhattanSpan: spans.manhattan,
+                long: longConnectorSpans(spans),
+            };
+        })
+            .sort((left, right) => compareCodeUnits(left.parentId, right.parentId) ||
+            compareCodeUnits(left.childId, right.childId)),
         layoutHash: hashCanonical(nodes.map(({ id, x, y, laneId }) => ({ id, laneId, x, y }))),
     };
 }

package/dist/hoi4_agent_tools/focus/render.js

@@ -334,6 +334,7 @@ function svgDocument(plan, layout, diagnostics, options) {
             nodes,
             decisions: layout.decisions,
             metrics: layout.metrics ?? null,
+            connectorMeasurements: layout.connectorMeasurements ?? null,
         },
         focuses: [...plan.focuses]
             .sort((left, right) => compareCodeUnits(left.id, right.id))
@@ -452,6 +453,47 @@ export async function renderFocusTree(plan, layout, diagnostics, options = {}) {
             .png({ compressionLevel: 9, adaptiveFiltering: false, palette: false })
             .toBuffer();
     }
+    const problemCrops = [];
+    if ((options.cropFocusIds?.length ?? 0) > 0) {
+        if (options.cropFocusIds.length > 16)
+            throw new ServiceError('FOCUS_CROP_LIMIT', 'Focus render accepts at most 16 problem crops');
+        if (options.rasterize === false)
+            throw new ServiceError('FOCUS_CROP_REQUIRES_RASTER', 'Focus problem crops require raster output');
+        const nodes = new Map(layout.nodes.map((node) => [node.id, node]));
+        const minimumX = Math.min(...layout.nodes.map(({ x }) => x));
+        const minimumY = Math.min(...layout.nodes.map(({ y }) => y));
+        const horizontal = options.horizontalSpacing ?? FOCUS_HORIZONTAL_GRID_PIXELS;
+        const vertical = options.verticalSpacing ?? FOCUS_VERTICAL_GRID_PIXELS;
+        const padding = options.padding ?? 80;
+        const scale = options.outputScale ?? 1;
+        for (const focusId of [...new Set(options.cropFocusIds)]) {
+            const node = nodes.get(focusId);
+            if (node === undefined)
+                throw new ServiceError('FOCUS_CROP_FOCUS_MISSING', 'Problem crop names an unknown focus', {
+                    focusId,
+                });
+            const origin = focusNodeOrigin(node, minimumX, minimumY, padding, horizontal, vertical);
+            const centerX = Math.round((origin.x + FOCUS_NODE_WIDTH_PIXELS / 2) * scale);
+            const centerY = Math.round((origin.y + FOCUS_NODE_HEIGHT_PIXELS / 2) * scale);
+            const width = Math.min(rendered.width, 640);
+            const height = Math.min(rendered.height, 440);
+            budget.reserve(width, height, 'focus problem crop PNG');
+            const x = Math.max(0, Math.min(rendered.width - width, centerX - Math.floor(width / 2)));
+            const y = Math.max(0, Math.min(rendered.height - height, centerY - Math.floor(height / 2)));
+            const crop = await sharp(png)
+                .extract({ left: x, top: y, width, height })
+                .png({ compressionLevel: 9, adaptiveFiltering: false, palette: false })
+                .toBuffer();
+            problemCrops.push({
+                focusId,
+                bounds: { x, y, width, height },
+                png: crop,
+                diagnostics: diagnostics
+                    .filter((diagnostic) => focusIdForDiagnostic(diagnostic) === focusId)
+                    .map(({ code }) => code),
+            });
+        }
+    }
     options.signal?.throwIfAborted();
     return {
         html,
@@ -467,6 +509,7 @@ export async function renderFocusTree(plan, layout, diagnostics, options = {}) {
         sourceMap: compiled.sourceMap,
         width: rendered.width,
         height: rendered.height,
+        ...(problemCrops.length === 0 ? {} : { problemCrops }),
     };
 }
 export async function storeFocusRenderArtifacts(workspace, artifacts, plan, bundle, options = {}) {
@@ -534,5 +577,24 @@ export async function storeFocusRenderArtifacts(workspace, artifacts, plan, bund
             description: 'Source-hash-bound non-Clausewitz planning metadata',
         },
     ];
+    if (bundle.problemCrops !== undefined) {
+        for (const crop of bundle.problemCrops)
+            writes.push({
+                name: `${stem}.focus-problem-${safeArtifactStem(crop.focusId)}-${sha256Bytes(crop.focusId).slice(0, 8)}.png`,
+                mimeType: 'image/png',
+                content: crop.png,
+                provenance: {
+                    ...provenance,
+                    kind: 'focus-problem-crop',
+                    metadata: { ...provenance.metadata, focusId: crop.focusId, bounds: crop.bounds },
+                },
+            });
+        writes.push({
+            name: `${stem}.focus-problem-crops.json`,
+            mimeType: 'application/json',
+            content: `${canonicalJson(bundle.problemCrops.map(({ focusId, bounds, png, diagnostics }) => ({ focusId, bounds, sha256: sha256Bytes(png), diagnostics })))}\n`,
+            provenance: { ...provenance, kind: 'focus-problem-crop-manifest' },
+        });
+    }
     return artifacts.withAtomicChunkedWrites(workspace, writes, (stored) => Promise.resolve([...stored]), options.signal);
 }