@naniteninja/profile-comparison-lib 1.0.25 → 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;
@@ -2428,6 +2475,11 @@ class ProfileComparisonLibComponent {
         const idB = this.getLinkNodeId(b);
         return idA < idB ? `${idA}|${idB}` : `${idB}|${idA}`;
     }
+    getRuntimeLinkStrength(link) {
+        return link.kind === 'cross'
+            ? link.strength * 1.7
+            : link.strength * 1.12;
+    }
     selectLinksWithCaps(candidates, maxPerNode, minPerNode = 0) {
         if (!candidates.length || maxPerNode <= 0)
             return [];
@@ -2685,19 +2737,24 @@ class ProfileComparisonLibComponent {
         const dividerLeft = (zoneP1 + zoneShared) / 2;
         const dividerRight = (zoneShared + zoneP2) / 2;
         const laneGap = Math.max(4, Math.min(16, centerGuard * 0.45));
+        const sharedRawMin = Math.max(globalMinX, dividerLeft + laneGap);
+        const sharedRawMax = Math.min(globalMaxX, dividerRight - laneGap);
+        const sharedRawWidth = Math.max(0, sharedRawMax - sharedRawMin);
+        const sharedTighten = Math.max(12, Math.min(34, sharedRawWidth * 0.22));
+        const sharedMinWidth = Math.max(44, Math.min(84, maxHalfShared * 1.05));
         let p1BoundsMinX = globalMinX;
         let p1BoundsMaxX = Math.min(globalMaxX, dividerLeft - laneGap);
-        let sharedBoundsMinX = Math.max(globalMinX, dividerLeft + laneGap);
-        let sharedBoundsMaxX = Math.min(globalMaxX, dividerRight - laneGap);
+        let sharedBoundsMinX = Math.max(globalMinX, sharedRawMin + sharedTighten);
+        let sharedBoundsMaxX = Math.min(globalMaxX, sharedRawMax - sharedTighten);
         let p2BoundsMinX = Math.max(globalMinX, dividerRight + laneGap);
         let p2BoundsMaxX = globalMaxX;
         if (p1BoundsMaxX < p1BoundsMinX)
             p1BoundsMaxX = p1BoundsMinX;
         if (p2BoundsMinX > p2BoundsMaxX)
             p2BoundsMinX = p2BoundsMaxX;
-        if (sharedBoundsMaxX < sharedBoundsMinX) {
+        if (sharedBoundsMaxX - sharedBoundsMinX < sharedMinWidth) {
             const centerX = Math.max(globalMinX, Math.min(globalMaxX, zoneShared));
-            const fallbackHalfWidth = Math.max(6, Math.min(20, Math.max(0, p2BoundsMinX - p1BoundsMaxX) * 0.25));
+            const fallbackHalfWidth = sharedMinWidth / 2;
             sharedBoundsMinX = Math.max(globalMinX, centerX - fallbackHalfWidth);
             sharedBoundsMaxX = Math.min(globalMaxX, centerX + fallbackHalfWidth);
             if (sharedBoundsMaxX < sharedBoundsMinX) {
@@ -2721,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,
@@ -2772,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');
@@ -2781,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;
@@ -2838,8 +2928,8 @@ class ProfileComparisonLibComponent {
         };
         const crossCandidates = [];
         const intraCandidates = [];
-        const MIN_DIST = 62;
-        const SPAN = 92;
+        const MIN_DIST = 34;
+        const SPAN = 72;
         for (let i = 0; i < nodes.length; i++) {
             for (let j = i + 1; j < nodes.length; j++) {
                 if (!this.canLinkNodes(nodes[i], nodes[j]))
@@ -2873,9 +2963,9 @@ class ProfileComparisonLibComponent {
                         kind: 'intra',
                         source: groupNodes[i],
                         target: groupNodes[j],
-                        strength: 0.08 + normSim * 0.2,
+                        strength: 0.12 + normSim * 0.24,
                         similarity,
-                        distance: 50 + (1 - normSim) * 42,
+                        distance: 34 + (1 - normSim) * 46,
                     });
                 }
             }
@@ -2975,6 +3065,461 @@ class ProfileComparisonLibComponent {
                 node.vy = (node.vy ?? 0) + dy * alignStrength * alpha;
             });
         };
+        const linkRecords = links
+            .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: Number(link.similarity ?? link.strength ?? 0.5),
+                kind: link.kind,
+            };
+        })
+            .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);
+                const dist = Math.sqrt(dx * dx + dy * dy) || 1;
+                const normalizedSimilarity = Math.max(0, Math.min(1, record.similarity / maxLinkSimilarity));
+                const targetDistance = MIN_PAIR_DISTANCE + (MAX_PAIR_DISTANCE - MIN_PAIR_DISTANCE) * (1 - normalizedSimilarity);
+                if (dist <= targetDistance)
+                    return;
+                const pullGap = dist - targetDistance;
+                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)
@@ -2982,7 +3527,7 @@ class ProfileComparisonLibComponent {
                 .force('link', forceLink(links)
                 .id(d => d.id)
                 .distance(d => d.distance)
-                .strength(d => d.kind === 'cross' ? d.strength * 1.45 : d.strength * 0.86))
+                .strength(d => this.getRuntimeLinkStrength(d)))
                 .force('collide', forceCollide((d) => {
                 const baseRadius = getHalfWidth(d.label) * 0.55 + ProfileComparisonLibComponent.CHIP_COLLISION_BORDER_PADDING;
                 return Math.min(58, Math.max(ProfileComparisonLibComponent.CHIP_RADIUS + 8, baseRadius));
@@ -2992,7 +3537,12 @@ class ProfileComparisonLibComponent {
                 .force('xBound', forceX(d => d.targetX ?? zoneShared)
                 .strength(d => d.group === 'shared' ? 1.15 : 0.85))
                 .force('yTargetSeed', forceY(d => d.targetY ?? minCenterY).strength(0.1))
-                .force('crossAlign', crossAlignForce);
+                .force('crossAlign', crossAlignForce)
+                .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 => {
@@ -3008,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.16 : 0.075));
-            sim.force('yTarget', forceY(d => d.originalFy ?? d.y ?? 0).strength(0.085));
+                .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];
@@ -3439,85 +3990,23 @@ class ProfileComparisonLibComponent {
         }
     }
     /**
-     * Installs (or removes) a custom d3 force that pulls every linked node toward
-     * the anchor, stopping at an orbit radius scaled by similarity:
-     *   highest-sim → MIN_ORBIT (touches anchor), lowest-sim → MAX_ORBIT.
-     *
-     * While active, the xTarget/yTarget restoring forces are muted so they don't
-     * fight the attraction. They are restored the moment attraction is cleared.
+     * Anchor interaction should only affect highlighting/energy.
+     * Similarity attraction is always-on via the base simulation forces.
      */
     updateAttractionForce(anchorNode) {
         if (!this.simulation)
             return;
-        if (!anchorNode) {
-            this.simulation.force('attraction', null);
-            // Restore restoring forces so nodes spring back home
-            const xT = this.simulation.force('xTarget');
-            if (xT)
-                xT.strength(0.1);
-            const yT = this.simulation.force('yTarget');
-            if (yT)
-                yT.strength(0.1);
-            const col = this.simulation.force('collide');
-            if (col)
-                col.strength(1.0);
-            this.simulation.alphaTarget(0);
-            this.simulation.alpha(0.6).restart();
-            return;
+        this.simulation.force('attraction', null);
+        if (anchorNode) {
+            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(ProfileComparisonLibComponent.IDLE_ALPHA_TARGET);
         }
-        // Collect connected node IDs and their similarity values
-        const linkSim = new Map();
-        this.forceLinks.forEach(link => {
-            const srcId = typeof link.source === 'object' ? link.source.id : link.source;
-            const tgtId = typeof link.target === 'object' ? link.target.id : link.target;
-            const sim = Number(link.similarity ?? link.strength ?? 0.5);
-            if (srcId === anchorNode.id)
-                linkSim.set(String(tgtId), sim);
-            if (tgtId === anchorNode.id)
-                linkSim.set(String(srcId), sim);
-        });
-        const simValues = Array.from(linkSim.values());
-        const maxSim = simValues.length ? Math.max(...simValues) : 1;
-        // Closest chip (highest sim) touches the anchor (36px ≈ one chip height).
-        // Others are spread tightly between 36–80px.
-        const MIN_ORBIT = 36; // px — highest-sim chip: touching
-        const MAX_ORBIT = 80; // px — lowest-sim chip: still very close
-        const PULL = 0.5; // strong pull — overcomes any residual forces
-        // Mute the forces that would fight the pull while attraction is active
-        const xT = this.simulation.force('xTarget');
-        if (xT)
-            xT.strength(0);
-        const yT = this.simulation.force('yTarget');
-        if (yT)
-            yT.strength(0);
-        const col = this.simulation.force('collide');
-        if (col)
-            col.strength(0.35); // keep slight chip separation while still allowing orbiting
-        const attractionForce = (alpha) => {
-            const ax = anchorNode.x ?? 0;
-            const ay = anchorNode.y ?? 0;
-            this.forceNodes.forEach(n => {
-                if (n.id === anchorNode.id)
-                    return;
-                const sim = linkSim.get(n.id);
-                if (sim === undefined)
-                    return; // not connected — leave untouched
-                const normalizedSim = maxSim > 0 ? sim / maxSim : 0;
-                const orbitDist = MIN_ORBIT + (MAX_ORBIT - MIN_ORBIT) * (1 - normalizedSim);
-                const dx = ax - (n.x ?? 0);
-                const dy = ay - (n.y ?? 0);
-                const dist = Math.sqrt(dx * dx + dy * dy) || 1;
-                if (dist > orbitDist) {
-                    // Pull toward orbit boundary — proportional to gap remaining
-                    const factor = PULL * alpha * (dist - orbitDist) / dist;
-                    n.vx = (n.vx ?? 0) + dx * factor;
-                    n.vy = (n.vy ?? 0) + dy * factor;
-                }
-            });
-        };
-        this.simulation.force('attraction', attractionForce);
-        // alphaTarget 0.3 keeps alpha high so attraction stays strong indefinitely
-        this.simulation.alphaTarget(0.3).restart();
     }
     isNodeConnected(node) {
         if (!this.activeNode)
@@ -3609,21 +4098,21 @@ class ProfileComparisonLibComponent {
         if (this.simulation) {
             const linkForce = this.simulation.force('link');
             if (linkForce)
-                linkForce.strength((d) => d.strength * 0.6);
+                linkForce.strength((d) => this.getRuntimeLinkStrength(d));
             const collideForce = this.simulation.force('collide');
             if (collideForce)
                 collideForce.strength(1.0);
             const xTarget = this.simulation.force('xTarget');
             if (xTarget)
-                xTarget.strength(0.08);
+                xTarget.strength((d) => d.group === 'shared' ? 0.1 : 0.045);
             const yTarget = this.simulation.force('yTarget');
             if (yTarget)
-                yTarget.strength(0.08);
+                yTarget.strength(0.042);
         }
         // Pull connected chips toward the dragged node
         this.updateAttractionForce(node);
         // Wake up the simulation target to keep it highly active during drag
-        this.simulation.alphaTarget(0.3).restart();
+        this.simulation.alphaTarget(0.28).restart();
     }
     onDocumentDragMove(event) {
         if (!this.isDragging || !this.draggedNode)
@@ -3666,27 +4155,25 @@ class ProfileComparisonLibComponent {
         // Release the node. Clear fx and fy so it is no longer pinned to the mouse
         this.draggedNode.fx = undefined;
         this.draggedNode.fy = undefined;
-        // Remove attraction so connected chips return home
+        // Keep baseline similarity attraction and restoring forces active after drag release.
         this.simulation.force('attraction', null);
-        // Set other forces to 0 so all chips glide directly to their starting coordinates
         if (this.simulation) {
             const linkForce = this.simulation.force('link');
             if (linkForce)
-                linkForce.strength(0);
+                linkForce.strength((d) => this.getRuntimeLinkStrength(d));
             const collideForce = this.simulation.force('collide');
             if (collideForce)
-                collideForce.strength(0.92);
-            // Pull nodes smoothly and slowly back to their exact starting points
+                collideForce.strength(1.0);
             const xTarget = this.simulation.force('xTarget');
             if (xTarget)
-                xTarget.strength(0.13);
+                xTarget.strength((d) => d.group === 'shared' ? 0.1 : 0.045);
             const yTarget = this.simulation.force('yTarget');
             if (yTarget)
-                yTarget.strength(0.13);
+                yTarget.strength(0.042);
         }
         // Cool down simulation targets
-        this.simulation.alphaTarget(0);
-        this.simulation.alpha(0.6).restart();
+        this.simulation.alphaTarget(ProfileComparisonLibComponent.IDLE_ALPHA_TARGET);
+        this.simulation.alpha(0.2).restart();
         this.draggedNode = null;
         this.isDragging = false;
     }