hoi4-agent-tools 1.0.0 → 1.2.0

package/dist/hoi4_agent_tools/focus/compact.js

@@ -0,0 +1,432 @@
+import { compareCodeUnits } from '../core/canonical.js';
+import { ServiceError } from '../core/result.js';
+import { focusPlanHash, } from './model.js';
+import { FOCUS_LAYOUT_WORK_MAX } from './limits.js';
+import { FocusLayoutWorkBudget, layoutFocusTree, layoutFocusTreeAsync } from './layout.js';
+const COMPACT_SAME_ROW_SPACING = 2;
+const COMPACT_LANE_SPACING = 8;
+const SMALL_COMPACT_SCALES = [0.2, 0.3, 0.4, 0.55, 0.7, 0.9];
+const LARGE_COMPACT_SCALES = [0.55, 0.6, 0.7, 0.8];
+const COMPACT_LAYOUT_WORK_MAX = FOCUS_LAYOUT_WORK_MAX * 10;
+const COMPACT_HARD_DIAGNOSTICS = new Set([
+    'FOCUS_LAYOUT_CONNECTOR_CROSSING_UNSATISFIED',
+    'FOCUS_LAYOUT_COORDINATE_CONFLICT',
+    'FOCUS_LAYOUT_LANE_BOUNDS_UNSATISFIED',
+    'FOCUS_LAYOUT_MUTUAL_EXCLUSION_SPACING_UNSATISFIED',
+    'FOCUS_LAYOUT_PARENT_ORDER_UNSATISFIED',
+    'FOCUS_LAYOUT_SAME_ROW_SPACING_UNSATISFIED',
+    'FOCUS_LAYOUT_VISIBLE_OVERLAP',
+]);
+function compactLimits(focusCount, connectorCount) {
+    const graphScale = Math.sqrt(Math.max(1, focusCount));
+    const maximumHorizontalSpan = Math.max(14, Math.ceil(graphScale * 3));
+    const maximumVerticalSpan = Math.max(4, Math.ceil(Math.log2(Math.max(2, focusCount))));
+    return {
+        maximumColumns: Math.max(16, Math.ceil(graphScale * 5)),
+        maximumHorizontalSpan,
+        maximumVerticalSpan,
+        maximumManhattanSpan: maximumHorizontalSpan + maximumVerticalSpan,
+        maximumLongConnectors: Math.ceil(connectorCount * 0.05),
+        maximumNodeIntersections: Math.ceil(connectorCount * 0.12),
+        maximumSiblingDeviation: Math.max(2, Math.ceil(graphScale * 2)),
+        maximumTotalSiblingDeviation: Math.max(4, Math.ceil(focusCount * 0.5)),
+    };
+}
+function requiredMetrics(layout) {
+    if (layout.metrics !== undefined)
+        return layout.metrics;
+    throw new ServiceError('FOCUS_COMPACT_METRICS_REQUIRED', 'Compact focus reflow requires current layout quality metrics', { treeId: layout.treeId });
+}
+function absoluteCompactRegressions(layout) {
+    const metrics = requiredMetrics(layout);
+    const limits = compactLimits(layout.nodes.length, metrics.connectors.count);
+    return [
+        ...(layout.diagnostics.some(({ code }) => COMPACT_HARD_DIAGNOSTICS.has(code))
+            ? ['hardLayoutDiagnostics']
+            : []),
+        ...(metrics.connectors.crossingCount > 0 ? ['connectorCrossingCount'] : []),
+        ...(metrics.connectors.nodeIntersectionCount > limits.maximumNodeIntersections
+            ? ['connectorNodeIntersectionBudget']
+            : []),
+        ...(metrics.spacing.tooCloseSameRowPairCount > 0 ? ['sameRowSpacing'] : []),
+        ...(metrics.symmetry.maximumSiblingDeviation > 1 ? ['siblingMirrorDeviation'] : []),
+        ...(metrics.symmetry.totalSiblingDeviation > metrics.symmetry.siblingCohortCount
+            ? ['totalSiblingMirrorDeviation']
+            : []),
+        ...(metrics.symmetry.maximumSiblingAnchorDeviation > limits.maximumSiblingDeviation
+            ? ['maximumSiblingDeviationBudget']
+            : []),
+        ...(metrics.symmetry.totalSiblingAnchorDeviation > limits.maximumTotalSiblingDeviation
+            ? ['totalSiblingDeviationBudget']
+            : []),
+        ...(metrics.symmetry.boundingCenterOffsetTwice > 1 ? ['boundingCenter'] : []),
+        ...(metrics.bounds.columnCount > limits.maximumColumns ? ['columnBudget'] : []),
+        ...(metrics.connectors.maximumHorizontalSpan > limits.maximumHorizontalSpan
+            ? ['maximumHorizontalConnectorBudget']
+            : []),
+        ...(metrics.connectors.maximumVerticalSpan > limits.maximumVerticalSpan
+            ? ['maximumVerticalConnectorBudget']
+            : []),
+        ...(metrics.connectors.maximumManhattanSpan > limits.maximumManhattanSpan
+            ? ['maximumManhattanConnectorBudget']
+            : []),
+        ...(metrics.connectors.longConnectorCount > limits.maximumLongConnectors
+            ? ['longConnectorBudget']
+            : []),
+    ];
+}
+function relativeCompactRegressions(current, proposed) {
+    const before = requiredMetrics(current);
+    const after = requiredMetrics(proposed);
+    return [
+        ...(after.connectors.crossingCount > before.connectors.crossingCount
+            ? ['connectorCrossingCount']
+            : []),
+        ...(after.connectors.nodeIntersectionCount > before.connectors.nodeIntersectionCount
+            ? ['connectorNodeIntersectionCount']
+            : []),
+        ...(after.connectors.maximumHorizontalSpan > before.connectors.maximumHorizontalSpan
+            ? ['maximumHorizontalConnectorSpan']
+            : []),
+        ...(after.connectors.maximumVerticalSpan > before.connectors.maximumVerticalSpan
+            ? ['maximumVerticalConnectorSpan']
+            : []),
+        ...(after.connectors.maximumManhattanSpan > before.connectors.maximumManhattanSpan
+            ? ['maximumManhattanConnectorSpan']
+            : []),
+        ...(after.connectors.longConnectorCount > before.connectors.longConnectorCount
+            ? ['longConnectorCount']
+            : []),
+        ...(after.connectors.totalHorizontalSpan > before.connectors.totalHorizontalSpan
+            ? ['totalHorizontalConnectorSpan']
+            : []),
+        ...(after.connectors.totalManhattanSpan > before.connectors.totalManhattanSpan
+            ? ['totalManhattanConnectorSpan']
+            : []),
+        ...(after.bounds.columnCount > before.bounds.columnCount ? ['columnCount'] : []),
+        ...(after.bounds.rowCount > before.bounds.rowCount ? ['rowCount'] : []),
+    ];
+}
+function compactShape(plan, layout) {
+    return (plan.focuses.every(({ position }) => position.mode === 'auto') &&
+        plan.laneGroups.every(({ minimumX, maximumX }) => minimumX === undefined && maximumX === undefined) &&
+        absoluteCompactRegressions(layout).length === 0);
+}
+function prerequisiteIds(plan, focusId) {
+    const focus = plan.focuses.find(({ id }) => id === focusId);
+    return (focus?.prerequisites.groups
+        .flatMap(({ focusIds }) => focusIds)
+        .sort((left, right) => compareCodeUnits(left, right)) ?? []);
+}
+function focusLaneId(plan, focus) {
+    if (focus.laneId !== undefined)
+        return focus.laneId;
+    if (focus.branchId !== undefined) {
+        const branch = plan.branchGroups.find(({ id }) => id === focus.branchId);
+        return branch?.laneId ?? focus.branchId;
+    }
+    return 'default';
+}
+function compactLaneBases(plan) {
+    const configured = [...plan.laneGroups].sort((left, right) => left.order - right.order || compareCodeUnits(left.id, right.id));
+    const configuredIds = new Set(configured.map(({ id }) => id));
+    const discovered = [...new Set(plan.focuses.map((focus) => focusLaneId(plan, focus)))]
+        .filter((id) => !configuredIds.has(id))
+        .sort((left, right) => compareCodeUnits(left, right));
+    const laneIds = [...configured.map(({ id }) => id), ...discovered];
+    return new Map(laneIds.map((id, index) => [
+        id,
+        Math.round((index - (laneIds.length - 1) / 2) * COMPACT_LANE_SPACING),
+    ]));
+}
+function compactStructuralAnchorX(plan, focus, parents, preferredX, laneBases) {
+    const parentCoordinates = parents
+        .flatMap((focusId) => {
+        const coordinate = preferredX.get(focusId);
+        return coordinate === undefined ? [] : [coordinate];
+    })
+        .sort((left, right) => left - right);
+    if (parentCoordinates.length > 1 && focus.convergence) {
+        return Math.floor(parentCoordinates.reduce((total, coordinate) => total + coordinate, 0) /
+            parentCoordinates.length);
+    }
+    if (parentCoordinates.length > 0) {
+        const middle = Math.floor(parentCoordinates.length / 2);
+        if (parentCoordinates.length % 2 === 1)
+            return parentCoordinates[middle] ?? 0;
+        return Math.floor(((parentCoordinates[middle - 1] ?? 0) + (parentCoordinates[middle] ?? 0)) / 2);
+    }
+    return laneBases.get(focusLaneId(plan, focus)) ?? 0;
+}
+function mirrorSiblingCohorts(plan, preferredX, preferredY) {
+    const cohorts = new Map();
+    const laneBases = compactLaneBases(plan);
+    const childCounts = new Map();
+    for (const focus of plan.focuses) {
+        const parents = prerequisiteIds(plan, focus.id);
+        for (const parentId of parents)
+            childCounts.set(parentId, (childCounts.get(parentId) ?? 0) + 1);
+        const key = JSON.stringify([
+            parents.length === 0 ? focusLaneId(plan, focus) : null,
+            parents,
+            preferredY.get(focus.id) ?? 0,
+        ]);
+        const cohort = cohorts.get(key) ?? [];
+        cohort.push(focus.id);
+        cohorts.set(key, cohort);
+    }
+    for (const cohort of cohorts.values()) {
+        if (cohort.length < 2)
+            continue;
+        cohort.sort((left, right) => (preferredX.get(left) ?? 0) - (preferredX.get(right) ?? 0) || compareCodeUnits(left, right));
+        const coordinates = cohort.map((id) => preferredX.get(id) ?? 0);
+        const pairCount = Math.floor(coordinates.length / 2);
+        const focus = plan.focuses.find(({ id }) => id === cohort[0]);
+        if (focus === undefined)
+            continue;
+        // A leaf fan can be mirrored directly around its structural parent. For
+        // rooted subtrees, moving only the entry focuses would push the long
+        // connectors into their descendants; keep the subtree envelope's center
+        // until the bounded gateway refinement can move the common parent.
+        const leafFan = cohort.every((focusId) => (childCounts.get(focusId) ?? 0) === 0);
+        const mirroredAt = (centerTwice) => {
+            const mirrored = [...coordinates];
+            for (let index = 0; index < pairCount; index += 1) {
+                const opposite = coordinates.length - 1 - index;
+                const left = Math.round(((coordinates[index] ?? 0) + centerTwice - (coordinates[opposite] ?? 0)) / 2);
+                mirrored[index] = left;
+                mirrored[opposite] = centerTwice - left;
+            }
+            if (coordinates.length % 2 === 1)
+                mirrored[pairCount] = Math.round(centerTwice / 2);
+            let maximumLeft = centerTwice / 2 - (coordinates.length % 2 === 1 ? 2 : 1);
+            for (let index = pairCount - 1; index >= 0; index -= 1) {
+                const opposite = coordinates.length - 1 - index;
+                const left = Math.min(mirrored[index] ?? maximumLeft, maximumLeft);
+                mirrored[index] = left;
+                mirrored[opposite] = centerTwice - left;
+                maximumLeft = left - COMPACT_SAME_ROW_SPACING;
+            }
+            return mirrored;
+        };
+        const selfCenterTwice = (coordinates[0] ?? 0) + (coordinates.at(-1) ?? 0);
+        const anchorCenterTwice = 2 *
+            compactStructuralAnchorX(plan, focus, prerequisiteIds(plan, focus.id), preferredX, laneBases);
+        let mirrored = mirroredAt(leafFan ? anchorCenterTwice : selfCenterTwice);
+        if (leafFan) {
+            const cohortIds = new Set(cohort);
+            const y = preferredY.get(cohort[0] ?? '');
+            const otherCoordinates = plan.focuses.flatMap((candidate) => !cohortIds.has(candidate.id) && preferredY.get(candidate.id) === y
+                ? [preferredX.get(candidate.id) ?? 0]
+                : []);
+            if (mirrored.some((coordinate) => otherCoordinates.some((otherCoordinate) => Math.abs(coordinate - otherCoordinate) < COMPACT_SAME_ROW_SPACING))) {
+                mirrored = mirroredAt(selfCenterTwice);
+            }
+        }
+        for (const [index, focusId] of cohort.entries())
+            preferredX.set(focusId, mirrored[index] ?? 0);
+    }
+}
+function compactCandidate(plan, layout, scale, compressRows) {
+    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 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 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,
+    ]));
+    const rows = new Map();
+    for (const node of layout.nodes) {
+        const row = rows.get(node.y) ?? [];
+        row.push(node);
+        rows.set(node.y, row);
+    }
+    for (const row of rows.values()) {
+        row.sort((left, right) => left.x - right.x || compareCodeUnits(left.id, right.id));
+        const placed = [];
+        for (const [index, node] of row.entries()) {
+            const requested = preferredX.get(node.id) ?? 0;
+            placed.push(index === 0
+                ? requested
+                : Math.max(requested, (placed[index - 1] ?? 0) + COMPACT_SAME_ROW_SPACING));
+        }
+        const drift = Math.round(row.reduce((total, node, index) => total + (preferredX.get(node.id) ?? 0) - (placed[index] ?? 0), 0) / row.length);
+        for (const [index, node] of row.entries())
+            preferredX.set(node.id, (placed[index] ?? 0) + drift);
+    }
+    mirrorSiblingCohorts(plan, preferredX, preferredY);
+    const compacted = structuredClone(plan);
+    compacted.laneGroups = compacted.laneGroups.map(({ id, label, order }) => ({
+        id,
+        label,
+        order,
+    }));
+    for (const focus of compacted.focuses) {
+        focus.position = {
+            mode: 'auto',
+            pinned: false,
+            preferredX: preferredX.get(focus.id) ?? 0,
+            preferredY: preferredY.get(focus.id) ?? 0,
+        };
+    }
+    compacted.provenance.importedPlanHash = focusPlanHash(compacted);
+    return compacted;
+}
+function compactScore(layout) {
+    const metrics = requiredMetrics(layout);
+    return [
+        metrics.connectors.longConnectorCount,
+        metrics.connectors.maximumHorizontalSpan,
+        metrics.bounds.columnCount,
+        metrics.connectors.nodeIntersectionCount,
+        metrics.connectors.totalHorizontalSpan,
+        metrics.connectors.maximumManhattanSpan,
+        metrics.bounds.rowCount,
+        metrics.connectors.totalVerticalSpan,
+        layout.layoutHash,
+    ];
+}
+function betterScore(candidate, current) {
+    for (let index = 0; index < candidate.length; index += 1) {
+        const left = candidate[index];
+        const right = current[index];
+        if (left === right)
+            continue;
+        if (typeof left === 'number' && typeof right === 'number')
+            return left < right;
+        return String(left) < String(right);
+    }
+    return false;
+}
+function compactScales(focusCount) {
+    return focusCount <= 50
+        ? SMALL_COMPACT_SCALES
+        : focusCount <= 500
+            ? LARGE_COMPACT_SCALES
+            : focusCount <= 2_000
+                ? [0.55, 0.65, 0.75]
+                : [0.65];
+}
+/**
+ * Produces a gameplay-neutral compact-reflow plan. Several deterministic
+ * compression candidates are measured with the same layout engine; only a
+ * centered, crossing-free, evenly spaced, branch-balanced candidate that
+ * stays within absolute and source-relative connector budgets can win.
+ */
+export function compactFocusTreePlan(plan) {
+    const currentLayout = layoutFocusTree(plan);
+    if (compactShape(plan, currentLayout)) {
+        const stable = structuredClone(plan);
+        stable.provenance.importedPlanHash = focusPlanHash(stable);
+        return stable;
+    }
+    const scales = compactScales(plan.focuses.length);
+    let selected;
+    let fallback;
+    for (const scale of scales) {
+        for (const compressRows of plan.focuses.length <= 500 ? [false, true] : [false]) {
+            const candidate = compactCandidate(plan, currentLayout, scale, compressRows);
+            let layout;
+            try {
+                layout = layoutFocusTree(candidate);
+            }
+            catch (error) {
+                if (error instanceof ServiceError && error.code === 'FOCUS_LAYOUT_WORK_BUDGET_BLOCKED')
+                    continue;
+                throw error;
+            }
+            if (fallback === undefined ||
+                betterScore(compactScore(layout), compactScore(fallback.layout)))
+                fallback = { plan: candidate, layout };
+            if (absoluteCompactRegressions(layout).length > 0 ||
+                relativeCompactRegressions(currentLayout, layout).length > 0)
+                continue;
+            if (selected === undefined ||
+                betterScore(compactScore(layout), compactScore(selected.layout)))
+                selected = { plan: candidate, layout };
+        }
+    }
+    if (selected !== undefined)
+        return selected.plan;
+    if (fallback !== undefined) {
+        assertCompactLayoutQuality(currentLayout, fallback.layout);
+        return fallback.plan;
+    }
+    throw new ServiceError('FOCUS_COMPACT_LAYOUT_REQUIRED', 'Compact focus planning did not produce a measurable layout candidate', { treeId: plan.id });
+}
+/**
+ * Cooperative compact planning for protocol handlers. Candidate layouts share
+ * one work budget, and the selected layout is returned for validation/rendering.
+ */
+export async function compactFocusTreePlanAsync(plan, options = {}) {
+    const workBudget = new FocusLayoutWorkBudget(options.maximumWork ?? COMPACT_LAYOUT_WORK_MAX);
+    const layoutOptions = {
+        workBudget,
+        ...(options.signal === undefined ? {} : { signal: options.signal }),
+    };
+    const currentLayout = await layoutFocusTreeAsync(plan, layoutOptions);
+    if (compactShape(plan, currentLayout)) {
+        const stable = structuredClone(plan);
+        stable.provenance.importedPlanHash = focusPlanHash(stable);
+        return { plan: stable, currentLayout, proposedLayout: currentLayout };
+    }
+    let selected;
+    let fallback;
+    let exhausted;
+    candidateSearch: for (const scale of compactScales(plan.focuses.length)) {
+        for (const compressRows of plan.focuses.length <= 500 ? [false, true] : [false]) {
+            options.signal?.throwIfAborted();
+            const candidate = compactCandidate(plan, currentLayout, scale, compressRows);
+            let layout;
+            try {
+                layout = await layoutFocusTreeAsync(candidate, layoutOptions);
+            }
+            catch (error) {
+                if (error instanceof ServiceError && error.code === 'FOCUS_LAYOUT_WORK_BUDGET_BLOCKED') {
+                    exhausted = error;
+                    break candidateSearch;
+                }
+                throw error;
+            }
+            if (fallback === undefined ||
+                betterScore(compactScore(layout), compactScore(fallback.layout)))
+                fallback = { plan: candidate, layout };
+            if (absoluteCompactRegressions(layout).length > 0 ||
+                relativeCompactRegressions(currentLayout, layout).length > 0)
+                continue;
+            if (selected === undefined ||
+                betterScore(compactScore(layout), compactScore(selected.layout)))
+                selected = { plan: candidate, layout };
+        }
+    }
+    if (selected !== undefined) {
+        return { plan: selected.plan, currentLayout, proposedLayout: selected.layout };
+    }
+    if (exhausted !== undefined)
+        throw exhausted;
+    if (fallback !== undefined) {
+        assertCompactLayoutQuality(currentLayout, fallback.layout);
+        return { plan: fallback.plan, currentLayout, proposedLayout: fallback.layout };
+    }
+    throw new ServiceError('FOCUS_COMPACT_LAYOUT_REQUIRED', 'Compact focus planning did not produce a measurable layout candidate', { treeId: plan.id });
+}
+/** Refuses compact rewrites that are not clean or trade readability for a smaller canvas. */
+export function assertCompactLayoutQuality(current, proposed) {
+    const regressions = [
+        ...absoluteCompactRegressions(proposed),
+        ...(current === undefined ? [] : relativeCompactRegressions(current, 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 absolute or relative layout-quality gate', {
+        treeId: proposed.treeId,
+        regressions,
+        limits: compactLimits(proposed.nodes.length, requiredMetrics(proposed).connectors.count),
+        ...(current === undefined ? {} : { before: requiredMetrics(current) }),
+        proposed: requiredMetrics(proposed),
+    });
+}

package/dist/hoi4_agent_tools/focus/compiler.js

@@ -90,13 +90,7 @@ function positionLines(focus, layout) {
     if (focus.position.mode === 'fixed') {
         return [`x = ${focus.position.x}`, `y = ${focus.position.y}`];
     }
-    const placed = layoutNodeMap(layout ?? {
-        treeId: '',
-        nodes: [],
-        decisions: [],
-        diagnostics: [],
-        layoutHash: '',
-    }).get(focus.id);
+    const placed = layout === undefined ? undefined : layoutNodeMap(layout).get(focus.id);
     if (placed === undefined) {
         throw new ServiceError('FOCUS_LAYOUT_REQUIRED', `Automatic focus ${focus.id} has no layout position`, {
             focusId: focus.id,

package/dist/hoi4_agent_tools/focus/geometry.js

@@ -1,30 +1,217 @@
 // Shared visual contract for the renderer and constraint solver. Coordinates
-// remain ordinary HOI4 focus-grid units; the pixel conversion proves whether
-// two rendered node rectangles intersect.
+// remain ordinary HOI4 focus-grid units; connector geometry is converted to
+// the same deterministic pixel-space cubic used in SVG review artifacts.
 export const FOCUS_HORIZONTAL_GRID_PIXELS = 176;
 export const FOCUS_VERTICAL_GRID_PIXELS = 116;
 export const FOCUS_NODE_WIDTH_PIXELS = 144;
 export const FOCUS_NODE_HEIGHT_PIXELS = 76;
+export const FOCUS_CONNECTOR_FLATTEN_SEGMENTS = 24;
+const GEOMETRY_EPSILON = 1e-7;
+function resolvedGeometry(options) {
+    return {
+        horizontalSpacing: options.horizontalSpacing ?? FOCUS_HORIZONTAL_GRID_PIXELS,
+        verticalSpacing: options.verticalSpacing ?? FOCUS_VERTICAL_GRID_PIXELS,
+        nodeWidth: options.nodeWidth ?? FOCUS_NODE_WIDTH_PIXELS,
+        nodeHeight: options.nodeHeight ?? FOCUS_NODE_HEIGHT_PIXELS,
+        originX: options.originX ?? 0,
+        originY: options.originY ?? 0,
+    };
+}
 export function focusNodesVisiblyOverlap(left, right) {
     return (Math.abs(left.x - right.x) * FOCUS_HORIZONTAL_GRID_PIXELS < FOCUS_NODE_WIDTH_PIXELS &&
         Math.abs(left.y - right.y) * FOCUS_VERTICAL_GRID_PIXELS < FOCUS_NODE_HEIGHT_PIXELS);
 }
+export function focusNodeRectangle(node, options = {}) {
+    const geometry = resolvedGeometry(options);
+    const minimumX = geometry.originX + node.x * geometry.horizontalSpacing;
+    const minimumY = geometry.originY + node.y * geometry.verticalSpacing;
+    return {
+        minimumX,
+        minimumY,
+        maximumX: minimumX + geometry.nodeWidth,
+        maximumY: minimumY + geometry.nodeHeight,
+    };
+}
+/** The exact cubic rendered for a prerequisite connector. */
+export function focusConnectorCurve(parent, child, options = {}) {
+    const geometry = resolvedGeometry(options);
+    const parentRectangle = focusNodeRectangle(parent, geometry);
+    const childRectangle = focusNodeRectangle(child, geometry);
+    const start = {
+        x: (parentRectangle.minimumX + parentRectangle.maximumX) / 2,
+        y: parentRectangle.maximumY,
+    };
+    const end = {
+        x: (childRectangle.minimumX + childRectangle.maximumX) / 2,
+        y: childRectangle.minimumY,
+    };
+    const middleY = (start.y + end.y) / 2;
+    return {
+        start,
+        firstControl: { x: start.x, y: middleY },
+        secondControl: { x: end.x, y: middleY },
+        end,
+    };
+}
+/** Serialize the shared connector primitive without introducing renderer-only rounding. */
+export function focusConnectorSvgPath(curve) {
+    return `M ${curve.start.x} ${curve.start.y} C ${curve.firstControl.x} ${curve.firstControl.y}, ${curve.secondControl.x} ${curve.secondControl.y}, ${curve.end.x} ${curve.end.y}`;
+}
+function cubicCoordinate(start, firstControl, secondControl, end, progress) {
+    const remaining = 1 - progress;
+    return (remaining * remaining * remaining * start +
+        3 * remaining * remaining * progress * firstControl +
+        3 * remaining * progress * progress * secondControl +
+        progress * progress * progress * end);
+}
+/** Fixed-size flattening keeps intersection work deterministic and bounded. */
+export function flattenFocusConnectorCurve(curve) {
+    return Array.from({ length: FOCUS_CONNECTOR_FLATTEN_SEGMENTS + 1 }, (_unused, index) => {
+        const progress = index / FOCUS_CONNECTOR_FLATTEN_SEGMENTS;
+        return {
+            x: cubicCoordinate(curve.start.x, curve.firstControl.x, curve.secondControl.x, curve.end.x, progress),
+            y: cubicCoordinate(curve.start.y, curve.firstControl.y, curve.secondControl.y, curve.end.y, progress),
+        };
+    });
+}
+function pointBounds(points) {
+    let minimumX = Infinity;
+    let minimumY = Infinity;
+    let maximumX = -Infinity;
+    let maximumY = -Infinity;
+    for (const point of points) {
+        minimumX = Math.min(minimumX, point.x);
+        minimumY = Math.min(minimumY, point.y);
+        maximumX = Math.max(maximumX, point.x);
+        maximumY = Math.max(maximumY, point.y);
+    }
+    return { minimumX, minimumY, maximumX, maximumY };
+}
+function rectanglesOverlap(left, right) {
+    return !(left.maximumX < right.minimumX - GEOMETRY_EPSILON ||
+        right.maximumX < left.minimumX - GEOMETRY_EPSILON ||
+        left.maximumY < right.minimumY - GEOMETRY_EPSILON ||
+        right.maximumY < left.minimumY - GEOMETRY_EPSILON);
+}
 function orientation(first, second, third) {
-    return Math.sign((second.y - first.y) * (third.x - second.x) - (second.x - first.x) * (third.y - second.y));
-}
-/**
- * Returns true only for a proper interior intersection. Connector pairs that
- * merely touch, overlap collinearly, or share a focus endpoint are handled by
- * their callers and do not count as a crossing.
- */
-export function focusConnectorSegmentsProperlyCross(firstStart, firstEnd, secondStart, secondEnd) {
-    const values = [
-        orientation(firstStart, firstEnd, secondStart),
-        orientation(firstStart, firstEnd, secondEnd),
-        orientation(secondStart, secondEnd, firstStart),
-        orientation(secondStart, secondEnd, firstEnd),
+    const crossProduct = (second.x - first.x) * (third.y - first.y) - (second.y - first.y) * (third.x - first.x);
+    return Math.abs(crossProduct) <= GEOMETRY_EPSILON ? 0 : Math.sign(crossProduct);
+}
+function pointOnSegment(point, start, end) {
+    return (orientation(start, end, point) === 0 &&
+        point.x >= Math.min(start.x, end.x) - GEOMETRY_EPSILON &&
+        point.x <= Math.max(start.x, end.x) + GEOMETRY_EPSILON &&
+        point.y >= Math.min(start.y, end.y) - GEOMETRY_EPSILON &&
+        point.y <= Math.max(start.y, end.y) + GEOMETRY_EPSILON);
+}
+function segmentsIntersect(firstStart, firstEnd, secondStart, secondEnd) {
+    if (!rectanglesOverlap({
+        minimumX: Math.min(firstStart.x, firstEnd.x),
+        minimumY: Math.min(firstStart.y, firstEnd.y),
+        maximumX: Math.max(firstStart.x, firstEnd.x),
+        maximumY: Math.max(firstStart.y, firstEnd.y),
+    }, {
+        minimumX: Math.min(secondStart.x, secondEnd.x),
+        minimumY: Math.min(secondStart.y, secondEnd.y),
+        maximumX: Math.max(secondStart.x, secondEnd.x),
+        maximumY: Math.max(secondStart.y, secondEnd.y),
+    }))
+        return false;
+    const firstStartOrientation = orientation(firstStart, firstEnd, secondStart);
+    const firstEndOrientation = orientation(firstStart, firstEnd, secondEnd);
+    const secondStartOrientation = orientation(secondStart, secondEnd, firstStart);
+    const secondEndOrientation = orientation(secondStart, secondEnd, firstEnd);
+    if (firstStartOrientation * firstEndOrientation < 0 &&
+        secondStartOrientation * secondEndOrientation < 0)
+        return true;
+    return ((firstStartOrientation === 0 && pointOnSegment(secondStart, firstStart, firstEnd)) ||
+        (firstEndOrientation === 0 && pointOnSegment(secondEnd, firstStart, firstEnd)) ||
+        (secondStartOrientation === 0 && pointOnSegment(firstStart, secondStart, secondEnd)) ||
+        (secondEndOrientation === 0 && pointOnSegment(firstEnd, secondStart, secondEnd)));
+}
+function polylineSegments(points) {
+    const segments = [];
+    for (let index = 1; index < points.length; index += 1) {
+        const start = points[index - 1];
+        const end = points[index];
+        if (start === undefined || end === undefined)
+            continue;
+        segments.push({
+            start,
+            end,
+            minimumY: Math.min(start.y, end.y),
+            maximumY: Math.max(start.y, end.y),
+        });
+    }
+    return segments.sort((left, right) => left.minimumY - right.minimumY ||
+        left.maximumY - right.maximumY ||
+        left.start.x - right.start.x ||
+        left.end.x - right.end.x);
+}
+export function focusConnectorPolylinesIntersect(firstPoints, secondPoints) {
+    if (!rectanglesOverlap(pointBounds(firstPoints), pointBounds(secondPoints)))
+        return false;
+    const firstSegments = polylineSegments(firstPoints);
+    const secondSegments = polylineSegments(secondPoints);
+    let secondStartIndex = 0;
+    for (const first of firstSegments) {
+        while (secondStartIndex < secondSegments.length &&
+            (secondSegments[secondStartIndex]?.maximumY ?? Infinity) < first.minimumY - GEOMETRY_EPSILON)
+            secondStartIndex += 1;
+        for (let secondIndex = secondStartIndex; secondIndex < secondSegments.length; secondIndex += 1) {
+            const second = secondSegments[secondIndex];
+            if (second === undefined)
+                continue;
+            if (second.minimumY > first.maximumY + GEOMETRY_EPSILON)
+                break;
+            if (segmentsIntersect(first.start, first.end, second.start, second.end))
+                return true;
+        }
+    }
+    return false;
+}
+export function focusConnectorCurvesIntersect(first, second) {
+    return focusConnectorPolylinesIntersect(flattenFocusConnectorCurve(first), flattenFocusConnectorCurve(second));
+}
+export function focusConnectorsVisiblyIntersect(firstParent, firstChild, secondParent, secondChild, options = {}) {
+    return focusConnectorCurvesIntersect(focusConnectorCurve(firstParent, firstChild, options), focusConnectorCurve(secondParent, secondChild, options));
+}
+function pointInsideRectangle(point, rectangle) {
+    return (point.x >= rectangle.minimumX - GEOMETRY_EPSILON &&
+        point.x <= rectangle.maximumX + GEOMETRY_EPSILON &&
+        point.y >= rectangle.minimumY - GEOMETRY_EPSILON &&
+        point.y <= rectangle.maximumY + GEOMETRY_EPSILON);
+}
+export function focusConnectorPolylineIntersectsRectangle(points, rectangle) {
+    if (!rectanglesOverlap(pointBounds(points), rectangle))
+        return false;
+    const topLeft = { x: rectangle.minimumX, y: rectangle.minimumY };
+    const topRight = { x: rectangle.maximumX, y: rectangle.minimumY };
+    const bottomRight = { x: rectangle.maximumX, y: rectangle.maximumY };
+    const bottomLeft = { x: rectangle.minimumX, y: rectangle.maximumY };
+    const sides = [
+        [topLeft, topRight],
+        [topRight, bottomRight],
+        [bottomRight, bottomLeft],
+        [bottomLeft, topLeft],
     ];
-    return values.every((value) => value !== 0) && values[0] !== values[1] && values[2] !== values[3];
+    for (let index = 1; index < points.length; index += 1) {
+        const start = points[index - 1];
+        const end = points[index];
+        if (start === undefined || end === undefined)
+            continue;
+        if (pointInsideRectangle(start, rectangle) || pointInsideRectangle(end, rectangle))
+            return true;
+        if (sides.some(([sideStart, sideEnd]) => segmentsIntersect(start, end, sideStart, sideEnd)))
+            return true;
+    }
+    return false;
+}
+export function focusConnectorCurveIntersectsRectangle(curve, rectangle) {
+    return focusConnectorPolylineIntersectsRectangle(flattenFocusConnectorCurve(curve), rectangle);
+}
+export function focusConnectorIntersectsNode(parent, child, node, options = {}) {
+    return focusConnectorCurveIntersectsRectangle(focusConnectorCurve(parent, child, options), focusNodeRectangle(node, options));
 }
 export function focusNodeOrigin(node, minimumX, minimumY, padding, horizontalSpacing = FOCUS_HORIZONTAL_GRID_PIXELS, verticalSpacing = FOCUS_VERTICAL_GRID_PIXELS) {
     return {