@slicedearth/whoisleuth-cli 1.47.4 → 2.0.0

package/frontend/src/lib/analysis/utils.js

@@ -1,255 +0,0 @@
-// Browser-safe analysis helpers shared by the Svelte tools.
-import { serializeCsvCell, serializeCsvRows } from "../../../../lib/csv.mjs";
-import { hammingDistanceHex, isInformativePerceptualHash, isPerceptualHash, } from "../../../../lib/perceptual-hash-comparison.mjs";
-// Deliberately conservative (no +tags, no comments, no quoted local parts) -
-// this only gates whether a WHOIS/RDAP-sourced string is safe to drop into a
-// mailto: URI as the recipient, not a general email validator. mailto:
-// treats a comma as an additional-recipient separator (RFC 6068), so a
-// registrant/abuse-contact field containing e.g. "person@example.test,cc@hostile.example"
-// would silently add a second recipient to the outreach/abuse draft the user
-// opens - rejecting anything outside a single plain address closes that off.
-const SIMPLE_EMAIL_RE = /^[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Za-z]{2,}$/;
-const MAX_ENTITY_DISPLAY_LENGTH = 300;
-export function isValidEmailAddress(value) {
-    return typeof value === 'string' && SIMPLE_EMAIL_RE.test(value.trim());
-}
-// RDAP and compact availability results represent a registrar as an entity,
-// while some WHOIS paths retain the historical string field. Normalize both
-// forms before they reach UI summaries or browser-local evidence; blindly
-// calling String() on an entity would persist "[object Object]" and hide real
-// registrar changes. The backend already bounds these values, but this client
-// boundary revalidates the API response before retaining it.
-function plainRecord(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : null;
-}
-export function entityDisplayName(value) {
-    let candidate = value;
-    const record = plainRecord(value);
-    if (record) {
-        candidate = record.name || record.org || record.handle;
-    }
-    if (typeof candidate !== 'string' && typeof candidate !== 'number')
-        return null;
-    const normalized = String(candidate)
-        .replace(/[\u0000-\u001f\u007f]/g, ' ')
-        .replace(/\s+/g, ' ')
-        .trim()
-        .slice(0, MAX_ENTITY_DISPLAY_LENGTH);
-    return normalized || null;
-}
-export { hammingDistanceHex };
-// A dHash carries usable structure only when its set-bit count is away from
-// the degenerate extremes. The shared browser-safe contract applies the same
-// threshold during generation and comparison, including for older retained
-// profile values.
-export function isInformativeFaviconHash(hex) {
-    return isInformativePerceptualHash(hex);
-}
-function faviconRecord(value) {
-    const record = plainRecord(value);
-    if (!record || typeof record.domain !== 'string')
-        return null;
-    const faviconHash = typeof record.faviconHash === 'string' && record.faviconHash
-        ? record.faviconHash
-        : null;
-    const faviconPHash = isPerceptualHash(record.faviconPHash)
-        ? record.faviconPHash
-        : null;
-    return faviconHash || faviconPHash
-        ? { domain: record.domain, faviconHash, faviconPHash }
-        : null;
-}
-export function groupBySimilarFavicon(records, maxDistance) {
-    const items = Array.isArray(records)
-        ? records.map(faviconRecord).filter((record) => record !== null)
-        : [];
-    const parent = items.map((_, i) => i);
-    const find = (x) => {
-        let root = x;
-        while ((parent[root] ?? root) !== root)
-            root = parent[root] ?? root;
-        while ((parent[x] ?? x) !== root) {
-            const next = parent[x] ?? x;
-            parent[x] = root;
-            x = next;
-        }
-        return root;
-    };
-    const union = (a, b) => { const ra = find(a); const rb = find(b); if (ra !== rb)
-        parent[ra] = rb; };
-    // Exact-hash buckets first (cheap, and the only signal for undecodable icons).
-    const firstByHash = new Map();
-    items.forEach((r, i) => {
-        if (!r.faviconHash)
-            return;
-        const existing = firstByHash.get(r.faviconHash);
-        if (existing !== undefined)
-            union(i, existing);
-        else
-            firstByHash.set(r.faviconHash, i);
-    });
-    // Perceptual near-matches among records with an *informative* phash -
-    // degenerate hashes (solid/monotonic icons) are skipped so they don't all
-    // cluster together; they can still group via an exact-hash match above.
-    const withPhash = [];
-    items.forEach((r, i) => {
-        if (isInformativeFaviconHash(r.faviconPHash))
-            withPhash.push({ i, phash: r.faviconPHash });
-    });
-    for (let a = 0; a < withPhash.length; a += 1) {
-        for (let b = a + 1; b < withPhash.length; b += 1) {
-            const left = withPhash[a];
-            const right = withPhash[b];
-            if (!left || !right)
-                continue;
-            const distance = hammingDistanceHex(left.phash, right.phash);
-            if (distance !== null && distance <= maxDistance)
-                union(left.i, right.i);
-        }
-    }
-    const groups = new Map();
-    items.forEach((r, i) => {
-        const root = find(i);
-        if (!groups.has(root))
-            groups.set(root, []);
-        groups.get(root)?.push(r.domain);
-    });
-    return [...groups.values()].filter((domains) => domains.length >= 2);
-}
-export function toCsvValue(v) {
-    return serializeCsvCell(v);
-}
-export function rowsToCsv(rows) {
-    return serializeCsvRows(rows);
-}
-function splitDelimitedLine(line, delimiter = ',') {
-    const result = [];
-    let cur = '';
-    let inQuotes = false;
-    for (let i = 0; i < line.length; i += 1) {
-        const ch = line[i];
-        if (ch === '"') {
-            if (inQuotes && line[i + 1] === '"') {
-                cur += '"';
-                i += 1;
-            }
-            else {
-                inQuotes = !inQuotes;
-            }
-        }
-        else if (ch === delimiter && !inQuotes) {
-            result.push(cur);
-            cur = '';
-        }
-        else {
-            cur += ch;
-        }
-    }
-    result.push(cur);
-    return result.map((s) => s.trim());
-}
-const DOMAIN_HEADER_NAMES = ['domain', 'domain_name', 'domain name', 'hostname', 'name'];
-export const MAX_DOMAIN_INPUT_CHARACTERS = 2 * 1024 * 1024;
-export const MAX_DOMAIN_INPUT_BYTES = 2 * 1024 * 1024;
-export const MAX_DOMAIN_INPUT_LINES = 10_000;
-export const MAX_DOMAIN_INPUT_SEPARATORS = 20_000;
-function detectDelimiter(line) {
-    const candidates = [',', ';', '\t'];
-    let best = null;
-    let bestCount = 0;
-    for (const delimiter of candidates) {
-        const count = splitDelimitedLine(line, delimiter).length - 1;
-        if (count > bestCount) {
-            best = delimiter;
-            bestCount = count;
-        }
-    }
-    return best;
-}
-// Used only to distinguish a pasted delimiter-separated query list from a
-// headerless multi-column CSV. Server-side classifyQuery remains the
-// authoritative validator when the scan runs.
-function looksLikeLookupToken(value) {
-    const token = String(value || '').trim();
-    if (!token || /\s/.test(token))
-        return false;
-    if (/^AS\d+$/i.test(token) || /^\d{1,3}(?:\.\d{1,3}){3}$/.test(token) || token.includes(':'))
-        return true;
-    try {
-        const url = new URL(/^[a-z][a-z\d+.-]*:\/\//i.test(token) ? token : `https://${token}`);
-        return url.hostname.includes('.');
-    }
-    catch {
-        return false;
-    }
-}
-export function parseDomainInput(text) {
-    const source = String(text || '');
-    if (source.length > MAX_DOMAIN_INPUT_CHARACTERS) {
-        return { entries: [], duplicates: 0, usedHeader: false, tooLarge: true };
-    }
-    if (new TextEncoder().encode(source).byteLength > MAX_DOMAIN_INPUT_BYTES) {
-        return { entries: [], duplicates: 0, usedHeader: false, tooLarge: true };
-    }
-    let lineCount = 1;
-    let separatorCount = 0;
-    for (let index = 0; index < source.length; index += 1) {
-        const character = source[index];
-        if (character === '\n')
-            lineCount += 1;
-        if (character === ',' || character === ';' || character === '\t')
-            separatorCount += 1;
-        if (lineCount > MAX_DOMAIN_INPUT_LINES || separatorCount > MAX_DOMAIN_INPUT_SEPARATORS) {
-            return { entries: [], duplicates: 0, usedHeader: false, tooLarge: true };
-        }
-    }
-    const normalized = source.replace(/^\uFEFF/, '');
-    const lines = normalized.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-    if (lines.length === 0)
-        return { entries: [], duplicates: 0, usedHeader: false, tooLarge: false };
-    const firstLine = lines[0] ?? '';
-    const delimiter = detectDelimiter(firstLine);
-    const firstCells = delimiter ? splitDelimitedLine(firstLine, delimiter) : [firstLine];
-    const header = firstCells.map((cell) => cell.toLowerCase());
-    const domainColIdx = header.findIndex((cell) => DOMAIN_HEADER_NAMES.includes(cell));
-    const usedHeader = domainColIdx !== -1;
-    let candidates;
-    if (usedHeader) {
-        candidates = lines.slice(1).map((line) => {
-            const rowDelimiter = delimiter || detectDelimiter(line);
-            const cells = rowDelimiter ? splitDelimitedLine(line, rowDelimiter) : [line];
-            return cells[domainColIdx] || '';
-        });
-    }
-    else {
-        const rows = lines.map((line) => {
-            const rowDelimiter = detectDelimiter(line);
-            return rowDelimiter ? splitDelimitedLine(line, rowDelimiter) : [line];
-        });
-        const flattened = rows.flat().map((cell) => cell.trim()).filter(Boolean);
-        // If every cell looks like a query, this is a pasted comma/semicolon list
-        // (possibly wrapped over several lines). Otherwise retain column zero so
-        // a headerless "domain,notes" CSV does not scan its notes as domains.
-        candidates = lines.length === 1 || (flattened.length > 0 && flattened.every(looksLikeLookupToken))
-            ? flattened
-            : rows.map((cells) => cells[0] || '');
-    }
-    const entries = [];
-    const seen = new Set();
-    let duplicates = 0;
-    for (const candidate of candidates) {
-        const value = String(candidate || '').trim();
-        if (!value)
-            continue;
-        const key = value.toLowerCase();
-        if (seen.has(key)) {
-            duplicates += 1;
-            continue;
-        }
-        seen.add(key);
-        entries.push(value);
-    }
-    return { entries, duplicates, usedHeader, tooLarge: false };
-}

package/frontend/src/lib/analysis/visualization-bounds.js

@@ -1,26 +0,0 @@
-export function boundedVisualizationText(value, maxLength) {
-    return String(value ?? '')
-        .replace(/[\u0000-\u001f\u007f]/gu, ' ')
-        .replace(/\s+/gu, ' ')
-        .trim()
-        .slice(0, maxLength);
-}
-export function boundedVisualizationId(value) {
-    return boundedVisualizationText(value, 64)
-        .toLowerCase()
-        .replace(/[^a-z0-9_-]+/gu, '-')
-        .replace(/^-+|-+$/gu, '');
-}
-export function boundedVisualizationNumber(value, minimum, maximum, fallback = 0) {
-    const number = Number(value);
-    return Number.isFinite(number)
-        ? Math.max(minimum, Math.min(maximum, number))
-        : fallback;
-}
-export function validVisualizationDate(value) {
-    const text = boundedVisualizationText(value, 64);
-    const milliseconds = Date.parse(text);
-    return Number.isFinite(milliseconds)
-        ? { text: new Date(milliseconds).toISOString(), milliseconds }
-        : null;
-}

package/frontend/src/lib/analysis/visualization-force-graph.js

@@ -1,352 +0,0 @@
-import { forceCenter, forceCollide, forceLink, forceManyBody, forceSimulation, forceX, forceY, } from 'd3-force';
-import { boundedVisualizationId as boundedId, boundedVisualizationText as boundedText, } from "./visualization-bounds.js";
-export const MAX_FORCE_GRAPH_NODES = 48;
-export const MAX_FORCE_GRAPH_LINKS = 80;
-export const FORCE_GRAPH_LINK_KINDS = [
-    'observed',
-    'partial',
-    'unknown',
-    'derived',
-    'summary',
-];
-function forceGraphLinkKind(value) {
-    const normalized = boundedId(value);
-    if (!normalized)
-        return 'observed';
-    return FORCE_GRAPH_LINK_KINDS.includes(normalized)
-        ? normalized
-        : 'unknown';
-}
-const FORCE_GRAPH_GROUPS = {
-    address: { id: 'network', label: 'Network' },
-    certificate: { id: 'certificate', label: 'Certificates' },
-    domain: { id: 'hosts', label: 'Domains and hosts' },
-    hostname: { id: 'hosts', label: 'Domains and hosts' },
-    identity: { id: 'identity', label: 'Identity' },
-    issuer: { id: 'certificate', label: 'Certificates' },
-    key: { id: 'certificate', label: 'Certificates' },
-    network: { id: 'network', label: 'Network' },
-    observation: { id: 'observations', label: 'Source observations' },
-    origin: { id: 'identity', label: 'Identity' },
-    prefix: { id: 'network', label: 'Network' },
-    registrar: { id: 'registration', label: 'Registration' },
-    relationship: { id: 'relationships', label: 'Shared evidence' },
-    service: { id: 'services', label: 'Services' },
-    summary: { id: 'summary', label: 'Grouped evidence' },
-    target: { id: 'focus', label: 'Lookup target' },
-    technology: { id: 'technology', label: 'Technology' },
-    tracker: { id: 'identity', label: 'Identity' },
-};
-const FORCE_GRAPH_CLUSTER_INDEX = {
-    certificate: 0,
-    hosts: 1,
-    identity: 2,
-    network: 3,
-    observations: 4,
-    registration: 5,
-    relationships: 6,
-    services: 7,
-    summary: 6,
-    technology: 7,
-};
-function forceGraphClusterIndex(group) {
-    const assigned = FORCE_GRAPH_CLUSTER_INDEX[group];
-    if (assigned !== undefined)
-        return assigned;
-    let hash = 0;
-    for (const [index, character] of [...group].entries()) {
-        hash = (hash + (character.codePointAt(0) ?? 0) * (index + 1)) % 8;
-    }
-    return hash;
-}
-function forceGraphGroup(kind, rawGroup, rawGroupLabel) {
-    const requested = boundedId(rawGroup);
-    const requestedLabel = boundedText(rawGroupLabel, 40);
-    if (requested) {
-        return {
-            id: requested,
-            label: requestedLabel || requested.replaceAll('-', ' ').replace(/\b\w/gu, (character) => character.toUpperCase()),
-        };
-    }
-    return FORCE_GRAPH_GROUPS[kind] ?? {
-        id: kind || 'evidence',
-        label: (kind || 'evidence').replaceAll('-', ' ').replace(/\b\w/gu, (character) => character.toUpperCase()),
-    };
-}
-function wrapForceGraphLabel(value, maximumLineLength = 20) {
-    const lines = [];
-    for (const word of value.split(/\s+/u).filter(Boolean)) {
-        const pieces = [];
-        let remaining = word;
-        while (remaining.length > maximumLineLength) {
-            let splitAt = maximumLineLength;
-            for (let index = maximumLineLength; index >= Math.floor(maximumLineLength * 0.55); index -= 1) {
-                if (/[./:_-]/u.test(remaining[index - 1] ?? '')) {
-                    splitAt = index;
-                    break;
-                }
-            }
-            pieces.push(remaining.slice(0, splitAt));
-            remaining = remaining.slice(splitAt);
-        }
-        if (remaining)
-            pieces.push(remaining);
-        for (const [pieceIndex, piece] of pieces.entries()) {
-            const current = lines.at(-1);
-            if (pieceIndex === 0 && current && current.length + piece.length + 1 <= maximumLineLength) {
-                lines[lines.length - 1] = `${current} ${piece}`;
-            }
-            else {
-                lines.push(piece);
-            }
-        }
-    }
-    return lines.length ? lines : [value];
-}
-function forceGraphClusterCenters(groups, width, height, hasFocus) {
-    const centerX = width / 2;
-    const centerY = height / 2;
-    const centers = new Map();
-    if (!groups.length)
-        return centers;
-    if (!hasFocus && groups.length === 1) {
-        centers.set(groups[0] ?? '', { x: centerX, y: centerY });
-        return centers;
-    }
-    if (!hasFocus && groups.length === 2) {
-        centers.set(groups[0] ?? '', { x: width * 0.29, y: centerY });
-        centers.set(groups[1] ?? '', { x: width * 0.71, y: centerY });
-        return centers;
-    }
-    if (hasFocus && groups.length === 1) {
-        centers.set(groups[0] ?? '', { x: width * 0.72, y: centerY });
-        return centers;
-    }
-    if (hasFocus && groups.length === 2) {
-        centers.set(groups[0] ?? '', { x: width * 0.25, y: centerY });
-        centers.set(groups[1] ?? '', { x: width * 0.75, y: centerY });
-        return centers;
-    }
-    const radiusX = hasFocus ? width * 0.33 : width * 0.27;
-    const radiusY = hasFocus ? Math.max(150, height * 0.36) : Math.max(125, height * 0.3);
-    for (const [index, group] of groups.entries()) {
-        const angle = -Math.PI / 2 + index * Math.PI * 2 / groups.length;
-        centers.set(group, {
-            x: centerX + Math.cos(angle) * radiusX,
-            y: centerY + Math.sin(angle) * radiusY,
-        });
-    }
-    return centers;
-}
-function forceGraphNodeBounds(node) {
-    if (node.kind === 'target') {
-        const halfWidth = (node.labelWidth + 20) / 2;
-        const halfHeight = (node.labelLines.length * 13 + 17) / 2;
-        return { halfWidth, above: halfHeight, below: halfHeight };
-    }
-    return {
-        halfWidth: Math.max(20, node.labelWidth / 2),
-        above: 22,
-        below: 33 + node.labelLines.length * 13,
-    };
-}
-function resolveForceGraphLabelCollisions(nodes, width, height, focusNodeId) {
-    const margin = 7;
-    for (let iteration = 0; iteration < 120; iteration += 1) {
-        let moved = false;
-        for (let leftIndex = 0; leftIndex < nodes.length; leftIndex += 1) {
-            const left = nodes[leftIndex];
-            if (!left)
-                continue;
-            const leftBounds = forceGraphNodeBounds(left);
-            for (let rightIndex = leftIndex + 1; rightIndex < nodes.length; rightIndex += 1) {
-                const right = nodes[rightIndex];
-                if (!right)
-                    continue;
-                const rightBounds = forceGraphNodeBounds(right);
-                const overlapX = leftBounds.halfWidth + rightBounds.halfWidth + margin - Math.abs(left.x - right.x);
-                const overlapY = Math.min(left.y + leftBounds.below, right.y + rightBounds.below) - Math.max(left.y - leftBounds.above, right.y - rightBounds.above) + margin;
-                if (overlapX <= 0 || overlapY <= 0)
-                    continue;
-                moved = true;
-                const leftFixed = left.id === focusNodeId;
-                const rightFixed = right.id === focusNodeId;
-                if (overlapX / (leftBounds.halfWidth + rightBounds.halfWidth) < overlapY / Math.max(leftBounds.above + leftBounds.below, rightBounds.above + rightBounds.below)) {
-                    const direction = left.x <= right.x ? -1 : 1;
-                    const shift = overlapX / (leftFixed || rightFixed ? 1 : 2) + 0.5;
-                    if (!leftFixed)
-                        left.x += direction * shift;
-                    if (!rightFixed)
-                        right.x -= direction * shift;
-                }
-                else {
-                    const direction = left.y <= right.y ? -1 : 1;
-                    const shift = overlapY / (leftFixed || rightFixed ? 1 : 2) + 0.5;
-                    if (!leftFixed)
-                        left.y += direction * shift;
-                    if (!rightFixed)
-                        right.y -= direction * shift;
-                }
-            }
-        }
-        for (const node of nodes) {
-            const bounds = forceGraphNodeBounds(node);
-            node.x = Math.max(bounds.halfWidth + margin, Math.min(width - bounds.halfWidth - margin, node.x));
-            node.y = Math.max(bounds.above + margin, Math.min(height - bounds.below - margin, node.y));
-        }
-        if (!moved)
-            break;
-    }
-}
-export function projectBoundedForceGraph(rawNodes, rawLinks, options = {}) {
-    const rawNodeCount = Array.isArray(rawNodes) ? rawNodes.length : 0;
-    const rawLinkCount = Array.isArray(rawLinks) ? rawLinks.length : 0;
-    const seen = new Set();
-    const candidates = (Array.isArray(rawNodes) ? rawNodes : [])
-        .slice(0, MAX_FORCE_GRAPH_NODES * 2)
-        .map((node) => {
-        const id = boundedText(node?.id, 80);
-        const label = boundedText(node?.label, 64);
-        if (!id || !label || seen.has(id))
-            return null;
-        seen.add(id);
-        const kind = boundedId(node?.kind) || 'evidence';
-        const group = forceGraphGroup(kind, node?.group, node?.groupLabel);
-        const labelLines = wrapForceGraphLabel(label);
-        const labelWidth = Math.max(54, Math.min(142, Math.max(...labelLines.map((line) => line.length)) * 6.2 + 16));
-        return {
-            id,
-            label,
-            labelLines,
-            labelWidth,
-            kind,
-            detail: boundedText(node?.detail, 100),
-            group: group.id,
-            groupLabel: group.label,
-            clusterIndex: 0,
-            collisionRadius: Math.max(38, labelWidth / 2 + 8, 30 + labelLines.length * 6),
-            x: 0,
-            y: 0,
-        };
-    })
-        .filter((node) => Boolean(node))
-        .sort((a, b) => a.id.localeCompare(b.id));
-    const nodes = candidates.slice(0, MAX_FORCE_GRAPH_NODES);
-    const nodeIds = new Set(nodes.map((node) => node.id));
-    const seenLinks = new Set();
-    const links = (Array.isArray(rawLinks) ? rawLinks : [])
-        .slice(0, MAX_FORCE_GRAPH_LINKS * 2)
-        .map((link, index) => ({
-        id: boundedText(link?.id, 80) || `link-${index}`,
-        source: boundedText(link?.source, 80),
-        target: boundedText(link?.target, 80),
-        kind: forceGraphLinkKind(link?.kind),
-        detail: boundedText(link?.detail, 100),
-    }))
-        .filter((link) => {
-        if (link.source === link.target
-            || !nodeIds.has(link.source)
-            || !nodeIds.has(link.target)
-            || seenLinks.has(link.id)) {
-            return false;
-        }
-        seenLinks.add(link.id);
-        return true;
-    })
-        .sort((a, b) => a.id.localeCompare(b.id))
-        .slice(0, MAX_FORCE_GRAPH_LINKS);
-    const requestedFocusId = boundedText(options.focusNodeId, 80);
-    const focusNode = nodes.find((node) => node.id === requestedFocusId)
-        ?? nodes.find((node) => node.kind === 'target');
-    const groupLabels = new Map();
-    for (const node of nodes) {
-        if (node.id !== focusNode?.id && !groupLabels.has(node.group))
-            groupLabels.set(node.group, node.groupLabel);
-    }
-    const groupIds = [...groupLabels.keys()].sort((left, right) => {
-        const leftLabel = groupLabels.get(left) ?? left;
-        const rightLabel = groupLabels.get(right) ?? right;
-        return leftLabel.localeCompare(rightLabel) || left.localeCompare(right);
-    });
-    const height = Math.max(500, Math.min(700, 450 + Math.max(0, nodes.length - 14) * 16));
-    const width = 900;
-    const centerX = width / 2;
-    const centerY = height / 2;
-    const clusterCenters = forceGraphClusterCenters(groupIds, width, height, Boolean(focusNode));
-    const clusterIndex = new Map(groupIds.map((group) => [group, forceGraphClusterIndex(group)]));
-    for (const node of nodes)
-        node.clusterIndex = clusterIndex.get(node.group) ?? 0;
-    if (nodes.length) {
-        if (focusNode) {
-            focusNode.fx = centerX;
-            focusNode.fy = centerY;
-        }
-        const simulation = forceSimulation(nodes)
-            .force('link', forceLink(links)
-            .id((node) => node.id)
-            .distance((link) => link.kind === 'derived' ? 145 : 125)
-            .strength(0.22))
-            .force('charge', forceManyBody().strength(-330))
-            .force('center', forceCenter(centerX, centerY))
-            .force('cluster-x', forceX((node) => node.id === focusNode?.id ? centerX : clusterCenters.get(node.group)?.x ?? centerX).strength(0.3))
-            .force('cluster-y', forceY((node) => node.id === focusNode?.id ? centerY : clusterCenters.get(node.group)?.y ?? centerY).strength(0.3))
-            .force('collide', forceCollide()
-            .radius((node) => node.kind === 'target' ? Math.max(66, node.collisionRadius) : node.collisionRadius)
-            .strength(1)
-            .iterations(5))
-            .stop();
-        simulation.tick(360);
-        for (const node of nodes) {
-            const horizontalInset = Math.max(38, Math.min(82, node.collisionRadius));
-            const topInset = node.kind === 'target' ? 28 : 34;
-            const bottomInset = Math.max(52, 34 + node.labelLines.length * 13);
-            node.x = Math.max(horizontalInset, Math.min(width - horizontalInset, Number(node.x) || centerX));
-            node.y = Math.max(topInset, Math.min(height - bottomInset, Number(node.y) || centerY));
-        }
-        resolveForceGraphLabelCollisions(nodes, width, height, focusNode?.id);
-    }
-    const projectedLinks = links.flatMap((link) => {
-        const source = typeof link.source === 'string' ? nodes.find((node) => node.id === link.source) : link.source;
-        const target = typeof link.target === 'string' ? nodes.find((node) => node.id === link.target) : link.target;
-        return source && target ? [{
-                id: link.id,
-                sourceId: source.id,
-                targetId: target.id,
-                sourceX: source.x,
-                sourceY: source.y,
-                targetX: target.x,
-                targetY: target.y,
-                kind: link.kind,
-                detail: link.detail,
-            }] : [];
-    });
-    const omittedNodeInputs = Math.max(0, rawNodeCount - nodes.length);
-    const omittedLinkInputs = Math.max(0, rawLinkCount - projectedLinks.length);
-    return {
-        width,
-        height,
-        nodes: nodes.map(({ id, label, labelLines, labelWidth, kind, detail, group, groupLabel, clusterIndex, x, y }) => ({
-            id,
-            label,
-            labelLines,
-            labelWidth,
-            kind,
-            detail,
-            group,
-            groupLabel,
-            clusterIndex,
-            x,
-            y,
-        })),
-        links: projectedLinks,
-        clusters: groupIds.map((group) => ({
-            id: group,
-            label: groupLabels.get(group) ?? group,
-            count: nodes.filter((node) => node.id !== focusNode?.id && node.group === group).length,
-            index: clusterIndex.get(group) ?? 0,
-        })),
-        omittedNodeInputs,
-        omittedLinkInputs,
-        truncated: omittedNodeInputs > 0 || omittedLinkInputs > 0,
-    };
-}