@slicedearth/whoisleuth-cli 1.45.0 → 2.0.0

package/frontend/src/lib/analysis/lookup-summary-model.js

@@ -1,398 +0,0 @@
-import { fmtAge, fmtExpiresIn, formatActivityCell, formatPrivacyCell, } from "./scoring.js";
-const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f]/gu;
-const MAX_SIGNALS = 12;
-const MAX_PROVENANCE_ITEMS = 8;
-const MAX_PROVENANCE_TEXT = 320;
-function record(value) {
-    return value && typeof value === 'object' && !Array.isArray(value)
-        ? value
-        : {};
-}
-function boundedText(value, maximum = 320) {
-    return String(value ?? '')
-        .replace(CONTROL_CHARACTERS, ' ')
-        .replace(/\s+/gu, ' ')
-        .trim()
-        .slice(0, maximum);
-}
-function display(value) {
-    if (value === null || value === undefined || value === '')
-        return '—';
-    if (Array.isArray(value)) {
-        return value.slice(0, 16).map((item) => boundedText(item, 120)).filter(Boolean).join(', ') || '—';
-    }
-    if (typeof value === 'object') {
-        const item = record(value);
-        return display(item.name || item.org || item.handle || item.domain);
-    }
-    return boundedText(value) || '—';
-}
-function textOrNull(value) {
-    const valueText = typeof value === 'string' ? boundedText(value) : '';
-    return valueText || null;
-}
-function records(value) {
-    return Array.isArray(value)
-        ? value.slice(0, 24).map(record).filter((item) => Object.keys(item).length > 0)
-        : [];
-}
-function textList(value, maximum = MAX_PROVENANCE_ITEMS) {
-    if (!Array.isArray(value))
-        return [];
-    const output = [];
-    const seen = new Set();
-    for (const item of value) {
-        const text = boundedText(item, MAX_PROVENANCE_TEXT);
-        if (!text || seen.has(text))
-            continue;
-        output.push(text);
-        seen.add(text);
-        if (output.length >= maximum)
-            break;
-    }
-    return output;
-}
-function formatDate(value) {
-    if (!value)
-        return '—';
-    const parsed = new Date(String(value));
-    return Number.isNaN(parsed.getTime()) ? boundedText(value) || '—' : parsed.toLocaleString();
-}
-function statusLabel(value) {
-    return boundedText(value, 64).replaceAll('_', ' ') || 'unknown';
-}
-function diagnosticDetail(value) {
-    const source = record(value);
-    const attempts = Array.isArray(source.attempts)
-        ? source.attempts.slice(0, 8).map((attempt) => (statusLabel(record(attempt).outcome))).join(' → ')
-        : '';
-    const parts = [
-        boundedText(source.endpoint, 2_048),
-        source.transportSecurity === 'http' ? 'transport: cleartext HTTP' : '',
-        typeof source.httpStatus === 'number' ? `HTTP ${source.httpStatus}` : '',
-        attempts ? `attempts: ${attempts}` : '',
-        source.resultState ? `result: ${boundedText(source.resultState, 80)}` : '',
-        boundedText(source.errorCode, 120),
-        source.authoritativeHop ? `authoritative: ${display(source.authoritativeHop)}` : '',
-        source.failedHop ? `failed: ${display(source.failedHop)}` : '',
-        source.fetchedAt ? `fetched ${formatDate(source.fetchedAt)}` : '',
-        source.queriedAt ? `queried ${formatDate(source.queriedAt)}` : '',
-    ].filter(Boolean);
-    return boundedText(parts.join(' · '), 2_400) || 'No additional source detail';
-}
-function sourceLabel(value) {
-    return {
-        dns: 'Authoritative DNS delegation',
-        rdap: 'Registry RDAP',
-        whois: 'WHOIS',
-    }[boundedText(value, 32)] || 'No conclusive registration source';
-}
-function sourceObservation(source, diagnostics, fallback) {
-    const sourceId = boundedText(source, 32);
-    const diagnostic = sourceId === 'dns'
-        ? record(diagnostics.availability)
-        : record(diagnostics[sourceId]);
-    return formatDate(diagnostic.fetchedAt
-        || diagnostic.queriedAt
-        || diagnostic.observedAt
-        || fallback);
-}
-function sourceCompleteness(source, diagnostics) {
-    const sourceId = boundedText(source, 32);
-    const diagnostic = sourceId === 'dns'
-        ? record(diagnostics.availability)
-        : record(diagnostics[sourceId]);
-    return statusLabel(diagnostic.status);
-}
-function registryLimitations(availability, rdapParsed, whoisParsed) {
-    const output = [
-        ...textList(availability.limitations),
-        ...textList(whoisParsed.limitations),
-    ];
-    if (rdapParsed.serverTruncated === true) {
-        output.push('The registry declared that the RDAP response omitted some data.');
-        output.push(...textList(rdapParsed.serverTruncationReasons));
-    }
-    return textList(output);
-}
-function comparisonConflicts(value, labels) {
-    const accepted = new Set(labels);
-    return records(record(value).fields)
-        .filter((field) => accepted.has(boundedText(field.label, 120)))
-        .filter((field) => boundedText(field.status, 64) === 'conflict')
-        .map((field) => boundedText(field.assessment
-        || `${display(field.rdapDisplay || field.registryDisplay)} differs from ${display(field.whoisDisplay || field.registrarDisplay)}`, MAX_PROVENANCE_TEXT))
-        .filter(Boolean)
-        .slice(0, MAX_PROVENANCE_ITEMS);
-}
-function factProvenance(input) {
-    return {
-        sources: [sourceLabel(input.source)],
-        observedAt: sourceObservation(input.source, input.diagnostics, input.observedAt),
-        fieldFamilies: input.fields.map((item) => boundedText(item, 160)).filter(Boolean),
-        normalization: boundedText(input.normalization, MAX_PROVENANCE_TEXT),
-        completeness: sourceCompleteness(input.source, input.diagnostics),
-        limitations: textList(input.limitations),
-        conflicts: textList(input.conflicts),
-        decisionImpact: boundedText(input.decisionImpact, MAX_PROVENANCE_TEXT),
-    };
-}
-function pushSignal(signals, signal) {
-    if (signal && signals.length < MAX_SIGNALS)
-        signals.push(signal);
-}
-function buildSignals(availability, profileSignals, idnAnalysis) {
-    const signals = [];
-    const trusted = boundedText(profileSignals.trusted, 80);
-    if (trusted)
-        pushSignal(signals, { label: `Trusted ${trusted}`, tone: 'good' });
-    if (profileSignals.faviconMatch === true) {
-        pushSignal(signals, { label: 'Favicon match', tone: 'danger' });
-    }
-    else if (profileSignals.faviconNearMatch === true) {
-        pushSignal(signals, { label: 'Favicon near-match', tone: 'warn' });
-    }
-    if (profileSignals.reusesOfficialAssets === true) {
-        pushSignal(signals, { label: 'Reuses official assets', tone: 'danger' });
-    }
-    if (availability.hasPasswordField === true) {
-        pushSignal(signals, { label: 'Password field', tone: 'warn' });
-    }
-    const phishingLanguage = textOrNull(availability.phishingLanguageMatch);
-    if (phishingLanguage) {
-        pushSignal(signals, {
-            label: 'Phishing language',
-            tone: 'danger',
-            detail: phishingLanguage,
-        });
-    }
-    if (idnAnalysis.mixedScript === true) {
-        pushSignal(signals, {
-            label: 'Mixed-script IDN',
-            tone: 'warn',
-            detail: 'The Unicode label combines writing scripts.',
-        });
-    }
-    if (Array.isArray(idnAnalysis.referenceMatches) && idnAnalysis.referenceMatches.length > 0) {
-        pushSignal(signals, {
-            label: 'Official-domain skeleton match',
-            tone: 'warn',
-            detail: 'A bounded visual skeleton matches an official domain in the active brand profile.',
-        });
-    }
-    const domainAgeDays = typeof availability.domainAgeDays === 'number'
-        ? availability.domainAgeDays
-        : null;
-    const age = fmtAge(domainAgeDays);
-    if (age)
-        pushSignal(signals, { label: age, tone: 'neutral' });
-    const expiresInDays = typeof availability.expiresInDays === 'number'
-        ? availability.expiresInDays
-        : null;
-    const expiry = fmtExpiresIn(expiresInDays);
-    if (expiry && expiresInDays !== null) {
-        pushSignal(signals, {
-            label: expiry,
-            tone: expiresInDays <= 60 ? 'warn' : 'neutral',
-        });
-    }
-    if (typeof availability.privacyProtected === 'boolean') {
-        pushSignal(signals, {
-            label: formatPrivacyCell(availability.privacyProtected),
-            tone: availability.privacyProtected ? 'warn' : 'good',
-        });
-    }
-    const activityStatus = textOrNull(availability.activityStatus);
-    if (activityStatus) {
-        const detail = textOrNull(availability.websiteProbeDetail);
-        pushSignal(signals, {
-            label: formatActivityCell(activityStatus, availability.hasMx === true, availability.hasSpf === true, availability.hasDmarc === true),
-            tone: activityStatus === 'active'
-                ? 'good'
-                : activityStatus === 'parked'
-                    ? 'warn'
-                    : 'neutral',
-            ...(detail ? { detail } : {}),
-        });
-    }
-    return signals;
-}
-function diagnosticAttempts(value) {
-    return records(value).slice(0, 8).map((attempt) => ({
-        endpoint: boundedText(attempt.endpoint, 2_048) || 'Endpoint not recorded',
-        outcome: statusLabel(attempt.outcome),
-        detail: boundedText(typeof attempt.status === 'number'
-            ? `HTTP ${attempt.status}${attempt.detail ? ` · ${boundedText(attempt.detail, 240)}` : ''}`
-            : attempt.detail, MAX_PROVENANCE_TEXT) || 'No additional attempt detail',
-    }));
-}
-function buildDiagnostics(diagnostics, rdapParsed, whoisParsed, registrarRdap) {
-    const sources = ['rdap', 'whois', 'availability'].map((source) => {
-        const item = record(diagnostics[source]);
-        const status = boundedText(item.status, 64);
-        const isRdap = source === 'rdap';
-        const isWhois = source === 'whois';
-        return {
-            source,
-            status,
-            label: statusLabel(status),
-            detail: diagnosticDetail(item),
-            endpoint: boundedText(item.endpoint, 2_048),
-            route: isRdap
-                ? 'The endpoint was selected through IANA RDAP bootstrap discovery and bounded endpoint failover.'
-                : isWhois
-                    ? 'The response follows the bounded WHOIS registry and referral chain shown below.'
-                    : 'This derived state applies the authority-aware availability rules to the collected registration evidence.',
-            observedAt: formatDate(item.fetchedAt || item.queriedAt || item.observedAt),
-            conformance: isRdap ? textList(rdapParsed.conformance) : [],
-            limitations: isRdap
-                ? registryLimitations({}, rdapParsed, {})
-                : isWhois
-                    ? textList(whoisParsed.limitations)
-                    : [],
-            attempts: diagnosticAttempts(item.attempts),
-        };
-    });
-    if (registrarRdap.status) {
-        const registrarDiagnostic = record(record(diagnostics.rdap).registrar);
-        const status = boundedText(registrarRdap.status || registrarDiagnostic.status, 64);
-        sources.push({
-            source: 'registrar RDAP',
-            status,
-            label: statusLabel(status),
-            detail: diagnosticDetail(registrarDiagnostic),
-            endpoint: boundedText(registrarRdap.endpoint || registrarDiagnostic.endpoint, 2_048),
-            route: 'This is a separately attributed registrar publication discovered from the registry RDAP response.',
-            observedAt: formatDate(registrarRdap.fetchedAt || registrarDiagnostic.fetchedAt),
-            conformance: textList(record(registrarRdap.parsed).conformance),
-            limitations: textList(registrarRdap.limitations),
-            attempts: diagnosticAttempts(registrarRdap.attempt ? [registrarRdap.attempt] : registrarDiagnostic.attempts),
-        });
-    }
-    const reverseDns = record(diagnostics.reverseDns);
-    if (reverseDns.status) {
-        const status = boundedText(reverseDns.status, 64);
-        sources.push({
-            source: 'reverse DNS',
-            status,
-            label: statusLabel(status),
-            detail: diagnosticDetail(reverseDns),
-            endpoint: '',
-            route: 'PTR evidence is non-authoritative context published by the address operator.',
-            observedAt: formatDate(reverseDns.observedAt),
-            conformance: [],
-            limitations: [],
-            attempts: [],
-        });
-    }
-    return sources;
-}
-export function buildLookupSummaryModel(input) {
-    const availability = record(input.availability);
-    const rdapParsed = record(input.rdapParsed);
-    const whoisParsed = record(input.whoisParsed);
-    const diagnostics = record(input.diagnostics);
-    const source = availability.source;
-    const limitations = registryLimitations(availability, rdapParsed, whoisParsed);
-    const registryComparison = input.registryComparison;
-    const registrarPublicationComparison = input.registrarPublicationComparison;
-    return {
-        signals: buildSignals(availability, record(input.profileSignals), record(input.idnAnalysis)),
-        facts: [
-            {
-                label: 'Registration',
-                value: display(availability.state || whoisParsed.registrationStatus),
-                detail: `${display(availability.confidence)} confidence`,
-                provenance: factProvenance({
-                    source,
-                    diagnostics,
-                    observedAt: input.resultObservedAt,
-                    fields: ['RDAP object state', 'WHOIS registration status', 'authoritative DNS delegation'],
-                    normalization: 'Authority-aware registration evidence is normalised into a stable availability state while inconclusive sources remain unknown.',
-                    limitations,
-                    conflicts: comparisonConflicts(registryComparison, ['Registration status']),
-                    decisionImpact: 'This is the authority-aware input to the availability result. This inspector does not recalculate or override that decision.',
-                }),
-            },
-            {
-                label: 'Registrar',
-                value: display(availability.registrar || rdapParsed.registrar || whoisParsed.registrar),
-                detail: display(whoisParsed.registrarUrl),
-                provenance: factProvenance({
-                    source,
-                    diagnostics,
-                    observedAt: input.resultObservedAt,
-                    fields: ['RDAP registrar entity', 'WHOIS Registrar', 'registrar RDAP registrar entity'],
-                    normalization: 'Structured registrar identities are reduced to a bounded display name while each registry, registrar, and WHOIS publication remains separate.',
-                    limitations,
-                    conflicts: [
-                        ...comparisonConflicts(registryComparison, ['Registrar', 'Registrar IANA ID']),
-                        ...comparisonConflicts(registrarPublicationComparison, ['Registrar', 'Registrar IANA ID']),
-                    ],
-                    decisionImpact: 'Registrar identity is investigative and contact context. It does not decide whether the domain exists or establish ownership.',
-                }),
-            },
-            {
-                label: 'Created',
-                value: formatDate(input.createdDate),
-                detail: fmtAge(typeof availability.domainAgeDays === 'number' ? availability.domainAgeDays : null) || 'Registry lifecycle date',
-                provenance: factProvenance({
-                    source,
-                    diagnostics,
-                    observedAt: input.resultObservedAt,
-                    fields: ['RDAP registration event or lifecycle', 'WHOIS creation-date family'],
-                    normalization: 'Recognised lifecycle dates are parsed into an ISO-compatible instant when possible; the original source publication remains authoritative.',
-                    limitations,
-                    conflicts: comparisonConflicts(registryComparison, ['Created']),
-                    decisionImpact: 'Domain age may contribute to an explainable score factor. It does not prove intent, ownership, or continuous operation.',
-                }),
-            },
-            {
-                label: 'Expires',
-                value: formatDate(input.expiresDate),
-                detail: fmtExpiresIn(typeof availability.expiresInDays === 'number' ? availability.expiresInDays : null) || 'Registry lifecycle date',
-                provenance: factProvenance({
-                    source,
-                    diagnostics,
-                    observedAt: input.resultObservedAt,
-                    fields: ['RDAP expiration event or lifecycle', 'WHOIS expiry-date family'],
-                    normalization: 'Recognised expiry dates are parsed into an ISO-compatible instant when possible without predicting deletion or release.',
-                    limitations,
-                    conflicts: comparisonConflicts(registryComparison, ['Expires']),
-                    decisionImpact: 'Expiry proximity may contribute to an explainable opportunity factor. It does not predict renewal, deletion, release, price, or eligibility.',
-                }),
-            },
-            {
-                label: 'Updated',
-                value: formatDate(input.updatedDate),
-                detail: 'Most recent registry change',
-                provenance: factProvenance({
-                    source,
-                    diagnostics,
-                    observedAt: input.resultObservedAt,
-                    fields: ['RDAP last-changed event or lifecycle', 'WHOIS updated-date family'],
-                    normalization: 'Recognised update dates are parsed into an ISO-compatible instant when possible and remain a source-reported lifecycle observation.',
-                    limitations,
-                    conflicts: comparisonConflicts(registryComparison, ['Updated']),
-                    decisionImpact: 'The update date is contextual evidence only and does not establish what changed or whether a website is active.',
-                }),
-            },
-            {
-                label: 'Website',
-                value: display(availability.activityStatus),
-                detail: display(availability.websiteProbeDetail),
-                provenance: {
-                    sources: ['Bounded homepage and favicon observation'],
-                    observedAt: formatDate(input.resultObservedAt),
-                    fieldFamilies: ['HTTP response', 'redirect chain', 'bounded homepage body', 'favicon response'],
-                    normalization: 'Observed responses are classified into active, parked, inactive, or unknown context without executing page scripts.',
-                    completeness: availability.deepScanComplete === false ? 'partial' : 'complete',
-                    limitations: textList(record(availability.http).limitations),
-                    conflicts: [],
-                    decisionImpact: 'Website activity can inform explainable analysis. A failed or missing response never implies inactivity, safety, or domain availability.',
-                },
-            },
-        ],
-        diagnostics: buildDiagnostics(diagnostics, rdapParsed, whoisParsed, record(input.registrarRdap)),
-    };
-}

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

@@ -1,55 +0,0 @@
-export { RISK_MODEL_VERSION, RISK_REVIEW_THRESHOLD, buildRiskScoreSensitivity, computeRiskScore, explainRiskScore, formatScoreBreakdown, normalizeRiskModelVersion, riskTone, } from "../../../../lib/risk-scoring.mjs";
-export { OPPORTUNITY_MODEL_VERSION, OPPORTUNITY_REVIEW_THRESHOLD, computeOpportunityScore, explainOpportunityScore, normalizeOpportunityModelVersion, opportunityTone, } from "../../../../lib/opportunity-scoring.mjs";
-export function fmtAge(value) {
-    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0)
-        return null;
-    const days = Math.round(value);
-    if (days < 60)
-        return `${days}d old`;
-    const years = days / 365.25;
-    return years < 1 ? `${Math.round(days / 30)}mo old` : `${years.toFixed(1)}y old`;
-}
-export function fmtExpiresIn(value) {
-    if (typeof value !== 'number' || !Number.isFinite(value))
-        return null;
-    const days = Math.round(value);
-    return days < 0 ? `expired ${Math.abs(days)}d ago` : `expires in ${days}d`;
-}
-export const ACTIVITY_LABELS = {
-    active: 'Active site',
-    parked: 'Parked / for-sale page',
-    unreachable: 'Website check inconclusive',
-    // Kept only so older saved watchlist snapshots remain readable. New scans
-    // use `unreachable`, because a fetch failure never proves that no site exists.
-    no_site: 'No site reported (legacy)',
-};
-export function formatPrivacyCell(v) {
-    if (v === true)
-        return 'Privacy protected';
-    if (v === false)
-        return 'Public registrant data';
-    return '—';
-}
-export function formatActivityCell(v, hasMx, hasSpf, hasDmarc) {
-    const label = typeof v === 'string' && v in ACTIVITY_LABELS
-        ? ACTIVITY_LABELS[v]
-        : '—';
-    const mailParts = [];
-    if (hasMx === true)
-        mailParts.push('MX');
-    if (hasSpf === true)
-        mailParts.push('SPF');
-    if (hasDmarc === true)
-        mailParts.push('DMARC');
-    return mailParts.length ? `${label} · ${mailParts.join('+')}` : label;
-}
-export function scoreTone(score) {
-    // Kept as a compatibility name for existing UI callers.
-    if (score === null)
-        return 'neutral';
-    if (score >= 70)
-        return 'good';
-    if (score >= 40)
-        return 'neutral';
-    return 'warn';
-}

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

@@ -1,232 +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'];
-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 normalized = String(text || '').replace(/^\uFEFF/, '');
-    const lines = normalized.split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
-    if (lines.length === 0)
-        return { entries: [], duplicates: 0, usedHeader: 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 };
-}