@naniteninja/profile-comparison-lib 1.0.26 → 1.0.27

package/fesm2022/naniteninja-profile-comparison-lib.mjs

@@ -17,9 +17,23 @@ var BackendMode;
     /** Use a local mock server at localhost:44101. */
     BackendMode[BackendMode["Mock"] = 1] = "Mock";
 })(BackendMode || (BackendMode = {}));
+const PROFILE_COMPARISON_PROD_API_BASE_URL = 'https://api.test.thecyrano.app/api/profile-comparison/api';
+const PROFILE_COMPARISON_LOCAL_API_BASE_URL = 'http://localhost:44101/api';
+function isLocalBrowserRuntime() {
+    if (typeof window === 'undefined') {
+        return false;
+    }
+    const hostname = window.location?.hostname?.toLowerCase() ?? '';
+    return hostname === 'localhost' || hostname === '127.0.0.1' || hostname === '0.0.0.0';
+}
+function resolveDefaultRealBackendUrl() {
+    return isLocalBrowserRuntime()
+        ? PROFILE_COMPARISON_LOCAL_API_BASE_URL
+        : PROFILE_COMPARISON_PROD_API_BASE_URL;
+}
 const BACKEND_MODE_URLS = {
-    [BackendMode.Real]: 'https://api.test.thecyrano.app/api/profile-comparison/api',
-    [BackendMode.Mock]: 'http://localhost:44101/api',
+    [BackendMode.Real]: resolveDefaultRealBackendUrl(),
+    [BackendMode.Mock]: PROFILE_COMPARISON_LOCAL_API_BASE_URL,
 };
 /**
  * Legacy injection token for the backend base URL.
@@ -1718,6 +1732,39 @@ class ProfileComparisonLibComponent {
     static MIN_CROSS_LINKS_PER_NODE = 0;
     static MAX_INTRA_LINKS_PER_NODE = 2;
     static MAX_RELEVANT_INTERESTS_PER_SIDE = 6;
+    static COLUMN_CORE_SEED_PIXELS = 9;
+    static IDLE_ALPHA_TARGET = 0.012;
+    static CLICK_REHEAT_ALPHA = 0.065;
+    static SEMANTIC_STABILITY_ALPHA_FLOOR = 0.012;
+    static RELATIVE_MEDIAN_ALPHA_FLOOR = 0.01;
+    static RELATIVE_MEDIAN_ATTRACT_STRENGTH = 0.44;
+    static RELATIVE_MEDIAN_REPEL_STRENGTH = 0.58;
+    static RELATIVE_MEDIAN_ATTRACT_RADIUS = 72;
+    static RELATIVE_MEDIAN_REPEL_RADIUS = 194;
+    static STRONG_SIMILARITY_BOOST_EXPONENT = 3.2;
+    static STRONG_SIMILARITY_BOOST_SCALE = 0.5;
+    static PRIORITY_PAIR_MIN_SIMILARITY = 0.62;
+    static PRIORITY_PAIR_ATTRACTION_STRENGTH = 1.02;
+    static PRIORITY_PAIR_CORRIDOR_RADIUS = 42;
+    static PRIORITY_PAIR_CORRIDOR_REPEL_STRENGTH = 0.64;
+    static MUTUAL_TOP_PAIR_MIN_SIMILARITY = 0.58;
+    static MUTUAL_TOP_PAIR_MARGIN = 0.12;
+    static MUTUAL_TOP_PAIR_ATTRACTION_STRENGTH = 1.12;
+    static MUTUAL_TOP_PAIR_BARRIER_RADIUS = 56;
+    static MUTUAL_TOP_PAIR_REPEL_STRENGTH = 1.06;
+    static DETERMINISTIC_SEED_PASSES = 6;
+    static DETERMINISTIC_SEED_BLEND = 0.86;
+    static OBJECTIVE_OPTIMIZER_ITERATIONS = 56;
+    static OBJECTIVE_STEP_START = 0.34;
+    static OBJECTIVE_STEP_END = 0.09;
+    static OBJECTIVE_ATTRACTION_WEIGHT = 0.74;
+    static OBJECTIVE_REPULSION_WEIGHT = 0.5;
+    static OBJECTIVE_ANCHOR_WEIGHT = 0.34;
+    static OBJECTIVE_BOUNDARY_WEIGHT = 0.92;
+    static DISSIMILAR_REPEL_THRESHOLD = 0.52;
+    static DISSIMILAR_REPEL_STRENGTH = 0.34;
+    static DISSIMILAR_REPEL_MAX_DISTANCE = 220;
+    static DISSIMILAR_REPEL_DECAY_DISTANCE = 130;
     static CHIP_RADIUS = 18; // half chip height for collision
     static CHIP_COLLISION_BORDER_PADDING = 6;
     static MAX_LINK_DISTANCE = 120;
@@ -2731,17 +2778,33 @@ class ProfileComparisonLibComponent {
         if (matrixMax <= springThreshold)
             matrixMax = 1.0;
         const simRange = matrixMax - springThreshold;
-        const distributedYForIndex = (index, total) => {
-            if (total <= 1)
-                return minCenterY + verticalSpan * 0.5;
-            const t = index / Math.max(1, total - 1);
-            return minCenterY + verticalSpan * t;
+        const columnCoreY = minCenterY + verticalSpan * 0.5;
+        const getMedian = (values) => {
+            if (!values.length)
+                return 0;
+            const sorted = [...values].sort((a, b) => a - b);
+            const mid = Math.floor(sorted.length / 2);
+            if (sorted.length % 2 === 1)
+                return sorted[mid];
+            return (sorted[mid - 1] + sorted[mid]) / 2;
+        };
+        const getTopSixMedian = (values) => {
+            if (!values.length)
+                return 0;
+            const top = [...values].sort((a, b) => b - a).slice(0, Math.min(6, values.length));
+            return getMedian(top);
+        };
+        const hashToken = (value) => {
+            let hash = 0;
+            for (let i = 0; i < value.length; i++) {
+                hash = ((hash << 5) - hash + value.charCodeAt(i)) | 0;
+            }
+            return Math.abs(hash);
         };
         const nodes = [];
         const addNodes = (items, group, zoneX) => {
-            const total = items.length;
             items.forEach((label, i) => {
-                const targetY = distributedYForIndex(i, total);
+                const targetY = columnCoreY;
                 nodes.push({
                     id: `${group}-${i}-${label}`,
                     label,
@@ -2782,8 +2845,10 @@ class ProfileComparisonLibComponent {
                     : zoneP2 + (zoneShared - zoneP2) * centerPull;
             }
         });
-        // Vertical placement should be driven by cross-list similarity, not by
-        // whichever list happens to have fewer items.
+        // Build a relative attractiveness score (median of top-six similarities)
+        // and seed chips from each column core with only a tiny 9x9 perturbation.
+        // This lets forces "emanate" from a shared origin while preserving
+        // deterministic reset behavior.
         const semanticPool = (node) => {
             if (node.group === 'p1')
                 return nodes.filter(n => n.group === 'p2' || n.group === 'shared');
@@ -2791,35 +2856,50 @@ class ProfileComparisonLibComponent {
                 return nodes.filter(n => n.group === 'p1' || n.group === 'shared');
             return nodes.filter(n => n.group === 'p1' || n.group === 'p2');
         };
-        const ySimilarityFloor = Math.max(0.18, springThreshold - 0.06);
-        for (let pass = 0; pass < 6; pass++) {
-            const snapshotY = new Map();
-            nodes.forEach(node => {
-                snapshotY.set(node.id, node.targetY ?? (minCenterY + verticalSpan * 0.5));
-            });
-            nodes.forEach(node => {
-                const pool = semanticPool(node);
-                if (!pool.length)
+        const getSemanticAttractiveness = (node) => {
+            const pool = semanticPool(node);
+            if (!pool.length)
+                return 0;
+            const similarities = pool.map(other => Math.max(0, this.getSimilarity(node.label, other.label)));
+            return getTopSixMedian(similarities);
+        };
+        const microSeedSpan = ProfileComparisonLibComponent.COLUMN_CORE_SEED_PIXELS;
+        const microSeedHalf = microSeedSpan / 2;
+        const deterministicPasses = ProfileComparisonLibComponent.DETERMINISTIC_SEED_PASSES;
+        const deterministicBlend = ProfileComparisonLibComponent.DETERMINISTIC_SEED_BLEND;
+        for (let pass = 0; pass < deterministicPasses; pass++) {
+            ['p1', 'shared', 'p2'].forEach(group => {
+                const groupNodes = nodes.filter(node => node.group === group);
+                if (groupNodes.length <= 1)
                     return;
-                let weightedY = 0;
-                let totalWeight = 0;
-                pool.forEach(other => {
-                    const similarity = this.getSimilarity(node.label, other.label);
-                    if (similarity < ySimilarityFloor)
-                        return;
-                    const weight = Math.pow(Math.max(0.001, similarity - ySimilarityFloor + 0.05), 2);
-                    const otherY = snapshotY.get(other.id) ?? (other.targetY ?? minCenterY);
-                    weightedY += otherY * weight;
-                    totalWeight += weight;
+                const ranked = groupNodes
+                    .map(node => ({
+                    node,
+                    attractiveness: getSemanticAttractiveness(node),
+                    tie: this.normalizeSimilarityToken(node.label),
+                }))
+                    .sort((a, b) => (b.attractiveness - a.attractiveness) || a.tie.localeCompare(b.tie));
+                ranked.forEach((entry, index) => {
+                    const rankT = ranked.length <= 1 ? 0.5 : (index / Math.max(1, ranked.length - 1));
+                    const yOffset = (rankT - 0.5) * microSeedSpan;
+                    const desiredY = Math.max(minCenterY, Math.min(maxY, columnCoreY + yOffset));
+                    const currentY = entry.node.targetY ?? columnCoreY;
+                    entry.node.targetY = Math.max(minCenterY, Math.min(maxY, currentY + (desiredY - currentY) * deterministicBlend));
+                    const xSeedRaw = hashToken(`${entry.node.id}:${pass}`) % (microSeedSpan + 1);
+                    const xOffset = xSeedRaw - microSeedHalf;
+                    const baseTargetX = entry.node.targetX ?? (entry.node.group === 'p1'
+                        ? zoneP1
+                        : (entry.node.group === 'p2' ? zoneP2 : zoneShared));
+                    entry.node.x = Math.max(globalMinX, Math.min(globalMaxX, baseTargetX + xOffset));
+                    entry.node.y = entry.node.targetY;
                 });
-                if (totalWeight <= 0)
-                    return;
-                const semanticY = weightedY / totalWeight;
-                const currentY = snapshotY.get(node.id) ?? semanticY;
-                const blend = node.group === 'shared' ? 0.84 : 0.78;
-                node.targetY = Math.max(minCenterY, Math.min(maxY, currentY + (semanticY - currentY) * blend));
             });
         }
+        nodes.forEach(node => {
+            const fallbackX = node.targetX ?? (node.group === 'p1' ? zoneP1 : (node.group === 'p2' ? zoneP2 : zoneShared));
+            node.x = Math.max(globalMinX, Math.min(globalMaxX, node.x ?? fallbackX));
+            node.y = Math.max(minCenterY, Math.min(maxY, node.targetY ?? columnCoreY));
+        });
         const buildNodeBounds = (node) => {
             let minX = globalMinX;
             let maxX = globalMaxX;
@@ -2999,10 +3079,96 @@ class ProfileComparisonLibComponent {
             };
         })
             .filter((record) => !!record);
+        const dissimilarThreshold = ProfileComparisonLibComponent.DISSIMILAR_REPEL_THRESHOLD;
+        const dissimilarPairs = [];
+        for (let i = 0; i < nodes.length; i++) {
+            for (let j = i + 1; j < nodes.length; j++) {
+                const source = nodes[i];
+                const target = nodes[j];
+                const similarity = Math.max(0, this.getSimilarity(source.label, target.label));
+                if (similarity >= dissimilarThreshold)
+                    continue;
+                const laneFactor = source.group === target.group
+                    ? 1
+                    : (source.group === 'shared' || target.group === 'shared' ? 0.62 : 0.44);
+                const repulsion = laneFactor * (dissimilarThreshold - similarity) / Math.max(0.001, dissimilarThreshold);
+                dissimilarPairs.push({
+                    source,
+                    target,
+                    repulsion,
+                });
+            }
+        }
+        const relativeMedianByNode = new Map();
+        const relativeMedianPairs = [];
+        ['p1', 'shared', 'p2'].forEach(group => {
+            const groupNodes = nodes.filter(node => node.group === group);
+            if (groupNodes.length <= 1)
+                return;
+            groupNodes.forEach(node => {
+                const similarities = groupNodes
+                    .filter(other => other.id !== node.id)
+                    .map(other => Math.max(0, this.getSimilarity(node.label, other.label)));
+                relativeMedianByNode.set(node.id, getTopSixMedian(similarities));
+            });
+            for (let i = 0; i < groupNodes.length; i++) {
+                for (let j = i + 1; j < groupNodes.length; j++) {
+                    const source = groupNodes[i];
+                    const target = groupNodes[j];
+                    const similarity = Math.max(0, this.getSimilarity(source.label, target.label));
+                    const sourceMedian = relativeMedianByNode.get(source.id) ?? 0;
+                    const targetMedian = relativeMedianByNode.get(target.id) ?? 0;
+                    const median = (sourceMedian + targetMedian) / 2;
+                    relativeMedianPairs.push({ source, target, similarity, median });
+                }
+            }
+        });
         const maxLinkSimilarity = Math.max(0.001, ...linkRecords.map(record => Math.max(0, record.similarity)));
         const MIN_PAIR_DISTANCE = 34;
         const MAX_PAIR_DISTANCE = 88;
+        const semanticAlphaFloor = ProfileComparisonLibComponent.SEMANTIC_STABILITY_ALPHA_FLOOR;
+        const relativeMedianColumnForce = (alpha) => {
+            const effectiveAlpha = Math.max(alpha, ProfileComparisonLibComponent.RELATIVE_MEDIAN_ALPHA_FLOOR);
+            const attractStrength = ProfileComparisonLibComponent.RELATIVE_MEDIAN_ATTRACT_STRENGTH;
+            const repelStrength = ProfileComparisonLibComponent.RELATIVE_MEDIAN_REPEL_STRENGTH;
+            const attractRadius = ProfileComparisonLibComponent.RELATIVE_MEDIAN_ATTRACT_RADIUS;
+            const repelRadius = ProfileComparisonLibComponent.RELATIVE_MEDIAN_REPEL_RADIUS;
+            const deltaDeadband = 0.025;
+            relativeMedianPairs.forEach(pair => {
+                const dx = (pair.target.x ?? 0) - (pair.source.x ?? 0);
+                const dy = (pair.target.y ?? 0) - (pair.source.y ?? 0);
+                const dist = Math.sqrt(dx * dx + dy * dy) || 1;
+                const delta = pair.similarity - pair.median;
+                if (Math.abs(delta) <= deltaDeadband)
+                    return;
+                if (delta >= 0) {
+                    const closenessBias = Math.max(0.08, Math.min(1, delta + 0.08));
+                    const targetDistance = Math.max(24, attractRadius - closenessBias * 46);
+                    if (dist <= targetDistance + 2)
+                        return;
+                    const pull = attractStrength * effectiveAlpha * closenessBias * ((dist - targetDistance) / dist);
+                    pair.source.vx = (pair.source.vx ?? 0) + dx * pull;
+                    pair.source.vy = (pair.source.vy ?? 0) + dy * pull;
+                    pair.target.vx = (pair.target.vx ?? 0) - dx * pull;
+                    pair.target.vy = (pair.target.vy ?? 0) - dy * pull;
+                    return;
+                }
+                if (dist >= repelRadius || dist <= 28)
+                    return;
+                const underMedian = Math.min(1, Math.abs(delta) / Math.max(0.001, pair.median + 0.05));
+                const push = repelStrength * effectiveAlpha * underMedian * (1 - (dist / repelRadius));
+                if (push <= 0)
+                    return;
+                const unitX = dx / dist;
+                const unitY = dy / dist;
+                pair.source.vx = (pair.source.vx ?? 0) - unitX * push;
+                pair.source.vy = (pair.source.vy ?? 0) - unitY * push;
+                pair.target.vx = (pair.target.vx ?? 0) + unitX * push;
+                pair.target.vy = (pair.target.vy ?? 0) + unitY * push;
+            });
+        };
         const similarityAttractionForce = (alpha) => {
+            const effectiveAlpha = Math.max(alpha, semanticAlphaFloor);
             linkRecords.forEach(record => {
                 const dx = (record.target.x ?? 0) - (record.source.x ?? 0);
                 const dy = (record.target.y ?? 0) - (record.source.y ?? 0);
@@ -3012,14 +3178,348 @@ class ProfileComparisonLibComponent {
                 if (dist <= targetDistance)
                     return;
                 const pullGap = dist - targetDistance;
-                const pullBase = record.kind === 'cross' ? 0.9 : 0.82;
-                const pullFactor = pullBase * alpha * (pullGap / dist);
+                const pullBase = record.kind === 'cross' ? 0.86 : 0.78;
+                const nonlinearBoost = 1
+                    + Math.pow(normalizedSimilarity, ProfileComparisonLibComponent.STRONG_SIMILARITY_BOOST_EXPONENT)
+                        * ProfileComparisonLibComponent.STRONG_SIMILARITY_BOOST_SCALE;
+                const pullFactor = pullBase * nonlinearBoost * effectiveAlpha * (pullGap / dist);
                 record.source.vx = (record.source.vx ?? 0) + dx * pullFactor;
                 record.source.vy = (record.source.vy ?? 0) + dy * pullFactor;
                 record.target.vx = (record.target.vx ?? 0) - dx * pullFactor;
                 record.target.vy = (record.target.vy ?? 0) - dy * pullFactor;
             });
         };
+        const dissimilarRepulsionForce = (alpha) => {
+            const effectiveAlpha = Math.max(alpha, semanticAlphaFloor * 0.9);
+            const maxDistance = ProfileComparisonLibComponent.DISSIMILAR_REPEL_MAX_DISTANCE;
+            const decayDistance = ProfileComparisonLibComponent.DISSIMILAR_REPEL_DECAY_DISTANCE;
+            const baseStrength = ProfileComparisonLibComponent.DISSIMILAR_REPEL_STRENGTH;
+            dissimilarPairs.forEach(record => {
+                const dx = (record.target.x ?? 0) - (record.source.x ?? 0);
+                const dy = (record.target.y ?? 0) - (record.source.y ?? 0);
+                const rawDistance = Math.sqrt(dx * dx + dy * dy) || 1;
+                if (rawDistance >= maxDistance)
+                    return;
+                const distance = Math.max(8, rawDistance);
+                const closeness = 1 - Math.min(1, distance / maxDistance);
+                const decay = Math.exp(-Math.pow(distance / Math.max(1, decayDistance), 2));
+                const push = baseStrength * effectiveAlpha * record.repulsion * closeness * decay;
+                if (push <= 0)
+                    return;
+                const unitX = dx / distance;
+                const unitY = dy / distance;
+                record.source.vx = (record.source.vx ?? 0) - unitX * push;
+                record.source.vy = (record.source.vy ?? 0) - unitY * push;
+                record.target.vx = (record.target.vx ?? 0) + unitX * push;
+                record.target.vy = (record.target.vy ?? 0) + unitY * push;
+            });
+        };
+        const priorityMinSimilarity = ProfileComparisonLibComponent.PRIORITY_PAIR_MIN_SIMILARITY;
+        const priorityPairCandidates = [...crossCandidates, ...intraCandidates]
+            .filter(link => link.similarity >= priorityMinSimilarity)
+            .sort((a, b) => (b.similarity - a.similarity) || (b.strength - a.strength));
+        const priorityPairKeys = new Set();
+        const endpointClaims = new Map();
+        const maxPairsPerNode = 2;
+        const getClaimCount = (id) => endpointClaims.get(id) ?? 0;
+        const priorityPairs = priorityPairCandidates
+            .filter(candidate => {
+            const sourceId = this.getLinkNodeId(candidate.source);
+            const targetId = this.getLinkNodeId(candidate.target);
+            const key = this.getLinkPairKey(sourceId, targetId);
+            if (priorityPairKeys.has(key))
+                return false;
+            if (getClaimCount(sourceId) >= maxPairsPerNode || getClaimCount(targetId) >= maxPairsPerNode)
+                return false;
+            priorityPairKeys.add(key);
+            endpointClaims.set(sourceId, getClaimCount(sourceId) + 1);
+            endpointClaims.set(targetId, getClaimCount(targetId) + 1);
+            return true;
+        })
+            .map(link => {
+            const source = typeof link.source === 'object' ? link.source : nodeById.get(String(link.source));
+            const target = typeof link.target === 'object' ? link.target : nodeById.get(String(link.target));
+            if (!source || !target)
+                return null;
+            return {
+                source,
+                target,
+                similarity: Math.max(priorityMinSimilarity, Number(link.similarity ?? 0)),
+            };
+        })
+            .filter((pair) => !!pair);
+        const maxPrioritySimilarity = Math.max(priorityMinSimilarity, ...priorityPairs.map(pair => pair.similarity));
+        const priorityPairForce = (alpha) => {
+            const effectiveAlpha = Math.max(alpha, semanticAlphaFloor);
+            const pairStrength = ProfileComparisonLibComponent.PRIORITY_PAIR_ATTRACTION_STRENGTH;
+            const corridorRadius = ProfileComparisonLibComponent.PRIORITY_PAIR_CORRIDOR_RADIUS;
+            const corridorRepel = ProfileComparisonLibComponent.PRIORITY_PAIR_CORRIDOR_REPEL_STRENGTH;
+            priorityPairs.forEach(pair => {
+                const ax = pair.source.x ?? 0;
+                const ay = pair.source.y ?? 0;
+                const bx = pair.target.x ?? 0;
+                const by = pair.target.y ?? 0;
+                const dx = bx - ax;
+                const dy = by - ay;
+                const dist = Math.sqrt(dx * dx + dy * dy) || 1;
+                const similarityNorm = Math.max(0, Math.min(1, pair.similarity / Math.max(0.001, maxPrioritySimilarity)));
+                const targetDistance = 26 + (1 - similarityNorm) * 20;
+                if (dist > targetDistance) {
+                    const pull = pairStrength * effectiveAlpha * ((dist - targetDistance) / dist);
+                    pair.source.vx = (pair.source.vx ?? 0) + dx * pull;
+                    pair.source.vy = (pair.source.vy ?? 0) + dy * pull;
+                    pair.target.vx = (pair.target.vx ?? 0) - dx * pull;
+                    pair.target.vy = (pair.target.vy ?? 0) - dy * pull;
+                }
+                const segmentLenSq = dx * dx + dy * dy;
+                if (segmentLenSq <= 1)
+                    return;
+                nodes.forEach(candidate => {
+                    if (candidate.id === pair.source.id || candidate.id === pair.target.id)
+                        return;
+                    const candidateSimilarity = Math.max(this.getSimilarity(candidate.label, pair.source.label), this.getSimilarity(candidate.label, pair.target.label));
+                    if (candidateSimilarity >= pair.similarity * 0.74)
+                        return;
+                    const px = candidate.x ?? 0;
+                    const py = candidate.y ?? 0;
+                    const tRaw = ((px - ax) * dx + (py - ay) * dy) / segmentLenSq;
+                    const t = Math.max(0, Math.min(1, tRaw));
+                    if (t <= 0.12 || t >= 0.88)
+                        return;
+                    const closestX = ax + dx * t;
+                    const closestY = ay + dy * t;
+                    const offX = px - closestX;
+                    const offY = py - closestY;
+                    const offDist = Math.sqrt(offX * offX + offY * offY) || 1;
+                    if (offDist >= corridorRadius)
+                        return;
+                    const proximity = 1 - (offDist / corridorRadius);
+                    const mismatch = 1 - Math.max(0, Math.min(1, candidateSimilarity / Math.max(0.001, pair.similarity)));
+                    const push = corridorRepel * effectiveAlpha * proximity * mismatch;
+                    if (push <= 0)
+                        return;
+                    const unitOffX = offX / offDist;
+                    const unitOffY = offY / offDist;
+                    candidate.vx = (candidate.vx ?? 0) + unitOffX * push;
+                    candidate.vy = (candidate.vy ?? 0) + unitOffY * push;
+                    // Counter-force keeps the pair stable while opening a semantic corridor.
+                    const damp = push * 0.24;
+                    pair.source.vx = (pair.source.vx ?? 0) - unitOffX * damp;
+                    pair.source.vy = (pair.source.vy ?? 0) - unitOffY * damp;
+                    pair.target.vx = (pair.target.vx ?? 0) - unitOffX * damp;
+                    pair.target.vy = (pair.target.vy ?? 0) - unitOffY * damp;
+                });
+            });
+        };
+        const bestByNode = new Map();
+        nodes.forEach(node => {
+            let bestNode = null;
+            let best = -1;
+            let second = -1;
+            nodes.forEach(other => {
+                if (other.id === node.id)
+                    return;
+                const similarity = Math.max(0, this.getSimilarity(node.label, other.label));
+                if (similarity > best) {
+                    second = best;
+                    best = similarity;
+                    bestNode = other;
+                }
+                else if (similarity > second) {
+                    second = similarity;
+                }
+            });
+            bestByNode.set(node.id, { node: bestNode, best: Math.max(0, best), second: Math.max(0, second) });
+        });
+        const mutualPairMinSimilarity = ProfileComparisonLibComponent.MUTUAL_TOP_PAIR_MIN_SIMILARITY;
+        const mutualPairMargin = ProfileComparisonLibComponent.MUTUAL_TOP_PAIR_MARGIN;
+        const mutualPairKeys = new Set();
+        const mutualTopPairs = nodes
+            .map(node => {
+            const best = bestByNode.get(node.id);
+            if (!best?.node)
+                return null;
+            if (best.best < mutualPairMinSimilarity)
+                return null;
+            if (best.best - best.second < mutualPairMargin)
+                return null;
+            const reverse = bestByNode.get(best.node.id);
+            if (!reverse?.node || reverse.node.id !== node.id)
+                return null;
+            if (reverse.best < mutualPairMinSimilarity || reverse.best - reverse.second < mutualPairMargin)
+                return null;
+            const key = this.getLinkPairKey(node.id, best.node.id);
+            if (mutualPairKeys.has(key))
+                return null;
+            mutualPairKeys.add(key);
+            return {
+                source: node,
+                target: best.node,
+                similarity: Math.min(best.best, reverse.best),
+            };
+        })
+            .filter((pair) => !!pair);
+        const mutualTopPairForce = (alpha) => {
+            const effectiveAlpha = Math.max(alpha, semanticAlphaFloor * 1.15);
+            const attractionStrength = ProfileComparisonLibComponent.MUTUAL_TOP_PAIR_ATTRACTION_STRENGTH;
+            const baseBarrierRadius = ProfileComparisonLibComponent.MUTUAL_TOP_PAIR_BARRIER_RADIUS;
+            const repelStrength = ProfileComparisonLibComponent.MUTUAL_TOP_PAIR_REPEL_STRENGTH;
+            mutualTopPairs.forEach(pair => {
+                const ax = pair.source.x ?? 0;
+                const ay = pair.source.y ?? 0;
+                const bx = pair.target.x ?? 0;
+                const by = pair.target.y ?? 0;
+                const dx = bx - ax;
+                const dy = by - ay;
+                const dist = Math.sqrt(dx * dx + dy * dy) || 1;
+                const norm = Math.max(0, Math.min(1, pair.similarity));
+                const targetDistance = 24 + (1 - norm) * 26;
+                if (dist > targetDistance) {
+                    const pull = attractionStrength * effectiveAlpha * ((dist - targetDistance) / dist);
+                    pair.source.vx = (pair.source.vx ?? 0) + dx * pull;
+                    pair.source.vy = (pair.source.vy ?? 0) + dy * pull;
+                    pair.target.vx = (pair.target.vx ?? 0) - dx * pull;
+                    pair.target.vy = (pair.target.vy ?? 0) - dy * pull;
+                }
+                const segmentLenSq = dx * dx + dy * dy;
+                if (segmentLenSq <= 1)
+                    return;
+                const barrierRadius = baseBarrierRadius + (1 - norm) * 10;
+                nodes.forEach(candidate => {
+                    if (candidate.id === pair.source.id || candidate.id === pair.target.id)
+                        return;
+                    const candidateSimilarity = Math.max(this.getSimilarity(candidate.label, pair.source.label), this.getSimilarity(candidate.label, pair.target.label));
+                    if (candidateSimilarity >= pair.similarity * 0.76)
+                        return;
+                    const px = candidate.x ?? 0;
+                    const py = candidate.y ?? 0;
+                    const tRaw = ((px - ax) * dx + (py - ay) * dy) / segmentLenSq;
+                    const t = Math.max(0, Math.min(1, tRaw));
+                    if (t <= 0.08 || t >= 0.92)
+                        return;
+                    const closestX = ax + dx * t;
+                    const closestY = ay + dy * t;
+                    const offX = px - closestX;
+                    const offY = py - closestY;
+                    const offDist = Math.sqrt(offX * offX + offY * offY) || 1;
+                    if (offDist >= barrierRadius)
+                        return;
+                    const proximity = 1 - (offDist / barrierRadius);
+                    const mismatch = 1 - Math.max(0, Math.min(1, candidateSimilarity / Math.max(0.001, pair.similarity)));
+                    const push = repelStrength * effectiveAlpha * proximity * mismatch;
+                    if (push <= 0)
+                        return;
+                    const unitOffX = offX / offDist;
+                    const unitOffY = offY / offDist;
+                    candidate.vx = (candidate.vx ?? 0) + unitOffX * push;
+                    candidate.vy = (candidate.vy ?? 0) + unitOffY * push;
+                    const damp = push * 0.26;
+                    pair.source.vx = (pair.source.vx ?? 0) - unitOffX * damp;
+                    pair.source.vy = (pair.source.vy ?? 0) - unitOffY * damp;
+                    pair.target.vx = (pair.target.vx ?? 0) - unitOffX * damp;
+                    pair.target.vy = (pair.target.vy ?? 0) - unitOffY * damp;
+                });
+            });
+        };
+        const runObjectiveOptimizer = () => {
+            if (!nodes.length)
+                return;
+            const attractionFloor = springThreshold;
+            const dissimilarFloor = dissimilarThreshold;
+            const pairRecords = [];
+            for (let i = 0; i < nodes.length; i++) {
+                for (let j = i + 1; j < nodes.length; j++) {
+                    const similarity = Math.max(0, this.getSimilarity(nodes[i].label, nodes[j].label));
+                    if (similarity <= dissimilarFloor || similarity >= attractionFloor) {
+                        pairRecords.push({ a: nodes[i], b: nodes[j], similarity });
+                    }
+                }
+            }
+            const iterations = ProfileComparisonLibComponent.OBJECTIVE_OPTIMIZER_ITERATIONS;
+            const stepStart = ProfileComparisonLibComponent.OBJECTIVE_STEP_START;
+            const stepEnd = ProfileComparisonLibComponent.OBJECTIVE_STEP_END;
+            const attractionWeight = ProfileComparisonLibComponent.OBJECTIVE_ATTRACTION_WEIGHT;
+            const repulsionWeight = ProfileComparisonLibComponent.OBJECTIVE_REPULSION_WEIGHT;
+            const anchorWeight = ProfileComparisonLibComponent.OBJECTIVE_ANCHOR_WEIGHT;
+            const boundaryWeight = ProfileComparisonLibComponent.OBJECTIVE_BOUNDARY_WEIGHT;
+            for (let iteration = 0; iteration < iterations; iteration++) {
+                const progress = iteration / Math.max(1, iterations - 1);
+                const step = stepStart + (stepEnd - stepStart) * progress;
+                const gradient = new Map();
+                nodes.forEach(node => gradient.set(node.id, { x: 0, y: 0 }));
+                pairRecords.forEach(record => {
+                    const ax = record.a.x ?? record.a.targetX ?? 0;
+                    const ay = record.a.y ?? record.a.targetY ?? 0;
+                    const bx = record.b.x ?? record.b.targetX ?? 0;
+                    const by = record.b.y ?? record.b.targetY ?? 0;
+                    const dx = bx - ax;
+                    const dy = by - ay;
+                    const dist = Math.sqrt(dx * dx + dy * dy) || 1;
+                    const unitX = dx / dist;
+                    const unitY = dy / dist;
+                    if (record.similarity >= attractionFloor) {
+                        const normalized = Math.max(0, Math.min(1, (record.similarity - attractionFloor) / Math.max(0.001, 1 - attractionFloor)));
+                        const targetDistance = 24 + (1 - normalized) * 66;
+                        if (dist > targetDistance) {
+                            const pull = attractionWeight * Math.pow(normalized, 1.4) * ((dist - targetDistance) / dist);
+                            const gradA = gradient.get(record.a.id);
+                            const gradB = gradient.get(record.b.id);
+                            if (gradA && gradB) {
+                                gradA.x += dx * pull;
+                                gradA.y += dy * pull;
+                                gradB.x -= dx * pull;
+                                gradB.y -= dy * pull;
+                            }
+                        }
+                        return;
+                    }
+                    if (record.similarity > dissimilarFloor)
+                        return;
+                    const normalized = (dissimilarFloor - record.similarity) / Math.max(0.001, dissimilarFloor);
+                    const maxDistance = 210;
+                    if (dist >= maxDistance)
+                        return;
+                    const push = repulsionWeight * normalized * (1 - (dist / maxDistance));
+                    const gradA = gradient.get(record.a.id);
+                    const gradB = gradient.get(record.b.id);
+                    if (gradA && gradB) {
+                        gradA.x -= unitX * push;
+                        gradA.y -= unitY * push;
+                        gradB.x += unitX * push;
+                        gradB.y += unitY * push;
+                    }
+                });
+                nodes.forEach(node => {
+                    const grad = gradient.get(node.id);
+                    if (!grad)
+                        return;
+                    const currentX = node.x ?? node.targetX ?? zoneShared;
+                    const currentY = node.y ?? node.targetY ?? minCenterY;
+                    const targetX = node.targetX ?? currentX;
+                    const targetY = node.targetY ?? currentY;
+                    grad.x += (targetX - currentX) * anchorWeight;
+                    grad.y += (targetY - currentY) * anchorWeight;
+                    const bounds = nodeBounds.get(node.id) ?? buildNodeBounds(node);
+                    if (currentX < bounds.minX)
+                        grad.x += (bounds.minX - currentX) * boundaryWeight;
+                    if (currentX > bounds.maxX)
+                        grad.x -= (currentX - bounds.maxX) * boundaryWeight;
+                    if (currentY < bounds.minY)
+                        grad.y += (bounds.minY - currentY) * boundaryWeight;
+                    if (currentY > bounds.maxY)
+                        grad.y -= (currentY - bounds.maxY) * boundaryWeight;
+                });
+                nodes.forEach(node => {
+                    const grad = gradient.get(node.id);
+                    if (!grad)
+                        return;
+                    node.x = (node.x ?? node.targetX ?? zoneShared) + grad.x * step;
+                    node.y = (node.y ?? node.targetY ?? minCenterY) + grad.y * step;
+                    clampNodeToBounds(node);
+                });
+            }
+        };
+        runObjectiveOptimizer();
         this.ngZone.runOutsideAngular(() => {
             const sim = forceSimulation(nodes)
                 .alphaDecay(0.014)
@@ -3038,7 +3538,11 @@ class ProfileComparisonLibComponent {
                 .strength(d => d.group === 'shared' ? 1.15 : 0.85))
                 .force('yTargetSeed', forceY(d => d.targetY ?? minCenterY).strength(0.1))
                 .force('crossAlign', crossAlignForce)
-                .force('similarityAttraction', similarityAttractionForce);
+                .force('relativeMedianColumn', relativeMedianColumnForce)
+                .force('similarityAttraction', similarityAttractionForce)
+                .force('dissimilarRepulsion', dissimilarRepulsionForce)
+                .force('priorityPair', priorityPairForce)
+                .force('mutualTopPair', mutualTopPairForce);
             for (let i = 0; i < 420 && sim.alpha() > 0.0035; i++) {
                 sim.tick();
                 nodes.forEach(n => {
@@ -3054,8 +3558,9 @@ class ProfileComparisonLibComponent {
             sim.force('yTargetSeed', null);
             sim.force('crossAlign', null);
             sim.force('xTarget', forceX(d => d.originalFx ?? d.x ?? 0)
-                .strength(d => d.group === 'shared' ? 0.12 : 0.045));
-            sim.force('yTarget', forceY(d => d.originalFy ?? d.y ?? 0).strength(0.045));
+                .strength(d => d.group === 'shared' ? 0.085 : 0.03));
+            sim.force('yTarget', forceY(d => d.originalFy ?? d.y ?? 0).strength(0.03));
+            sim.alphaTarget(ProfileComparisonLibComponent.IDLE_ALPHA_TARGET);
             this.simulation = sim;
             this.ngZone.run(() => {
                 this.forceNodes = [...nodes];
@@ -3493,10 +3998,14 @@ class ProfileComparisonLibComponent {
             return;
         this.simulation.force('attraction', null);
         if (anchorNode) {
-            this.simulation.alpha(0.24).restart();
+            const minClickAlpha = ProfileComparisonLibComponent.CLICK_REHEAT_ALPHA;
+            if (this.simulation.alpha() < minClickAlpha) {
+                this.simulation.alpha(minClickAlpha);
+            }
+            this.simulation.alphaTarget(ProfileComparisonLibComponent.IDLE_ALPHA_TARGET).restart();
         }
         else if (!this.isDragging) {
-            this.simulation.alphaTarget(0);
+            this.simulation.alphaTarget(ProfileComparisonLibComponent.IDLE_ALPHA_TARGET);
         }
     }
     isNodeConnected(node) {
@@ -3595,10 +4104,10 @@ class ProfileComparisonLibComponent {
                 collideForce.strength(1.0);
             const xTarget = this.simulation.force('xTarget');
             if (xTarget)
-                xTarget.strength((d) => d.group === 'shared' ? 0.12 : 0.05);
+                xTarget.strength((d) => d.group === 'shared' ? 0.1 : 0.045);
             const yTarget = this.simulation.force('yTarget');
             if (yTarget)
-                yTarget.strength(0.05);
+                yTarget.strength(0.042);
         }
         // Pull connected chips toward the dragged node
         this.updateAttractionForce(node);
@@ -3657,14 +4166,14 @@ class ProfileComparisonLibComponent {
                 collideForce.strength(1.0);
             const xTarget = this.simulation.force('xTarget');
             if (xTarget)
-                xTarget.strength((d) => d.group === 'shared' ? 0.12 : 0.045);
+                xTarget.strength((d) => d.group === 'shared' ? 0.1 : 0.045);
             const yTarget = this.simulation.force('yTarget');
             if (yTarget)
-                yTarget.strength(0.045);
+                yTarget.strength(0.042);
         }
         // Cool down simulation targets
-        this.simulation.alphaTarget(0);
-        this.simulation.alpha(0.4).restart();
+        this.simulation.alphaTarget(ProfileComparisonLibComponent.IDLE_ALPHA_TARGET);
+        this.simulation.alpha(0.2).restart();
         this.draggedNode = null;
         this.isDragging = false;
     }