@slicedearth/whoisleuth-cli 1.36.1 → 1.43.0

package/lib/opportunity-scoring.mjs

@@ -0,0 +1,107 @@
+import { buildScoreEvidenceQuality, } from "./scoring-evidence-quality.mjs";
+export const OPPORTUNITY_MODEL_VERSION = 2;
+export const OPPORTUNITY_REVIEW_THRESHOLD = 70;
+const STATE_BASE = Object.freeze({
+    available: 82,
+    for_sale: 70,
+    expiring: 52,
+    registered: 22,
+});
+const STATE_LABELS = Object.freeze({
+    available: 'available',
+    for_sale: 'registered with a sale signal',
+    expiring: 'registered in a lifecycle transition',
+    registered: 'registered',
+});
+function finite(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function formatAge(days) {
+    if (days < 60)
+        return `${Math.max(0, Math.round(days))}d old`;
+    const years = days / 365.25;
+    return years < 1 ? `${Math.round(days / 30)}mo old` : `${years.toFixed(1)}y old`;
+}
+function addFactor(factors, dimensions, family, label, delta) {
+    factors.push({ family, label, delta });
+    dimensions.set(family, (dimensions.get(family) ?? 0) + delta);
+}
+export function normalizeOpportunityModelVersion(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value > 0 && value <= 1000 ? value : null;
+}
+// Opportunity is acquisition readiness, not price, value, eligibility, or a
+// prediction that a registration will lapse. It uses only bounded evidence
+// already collected for the current lookup.
+export function explainOpportunityScore(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return null;
+    const input = value;
+    const state = input.availability ?? input.state;
+    if (typeof state !== 'string' || !Object.hasOwn(STATE_BASE, state))
+        return null;
+    const factors = [];
+    const dimensions = new Map();
+    addFactor(factors, dimensions, 'registration', `Base readiness for “${STATE_LABELS[state] ?? state}”`, STATE_BASE[state] ?? 0);
+    if (input.confidence === 'high')
+        addFactor(factors, dimensions, 'registration', 'High-confidence registration decision', 8);
+    else if (input.confidence === 'medium')
+        addFactor(factors, dimensions, 'registration', 'Medium-confidence registration decision', 3);
+    else if (input.confidence === 'low')
+        addFactor(factors, dimensions, 'registration', 'Low-confidence registration decision', -8);
+    if (state === 'for_sale')
+        addFactor(factors, dimensions, 'listing', 'Bounded sale signal observed; listing remains unverified', 6);
+    else if (input.activityStatus === 'parked')
+        addFactor(factors, dimensions, 'listing', 'Parked page observed without a verified sale offer', 3);
+    else if (state === 'registered' && input.activityStatus === 'active') {
+        addFactor(factors, dimensions, 'listing', 'Active website suggests an in-use registration', -12);
+    }
+    if (input.hasPublicRegistrantContact === true) {
+        addFactor(factors, dimensions, 'contactability', 'Public registrant contact route observed; acquisition suitability is not established', 10);
+    }
+    const expiresInDays = finite(input.expiresInDays);
+    if (state === 'registered' && expiresInDays !== null && expiresInDays >= 0 && expiresInDays < 30) {
+        addFactor(factors, dimensions, 'lifecycle', 'Published expiry is within 30 days; release is not implied', 4);
+    }
+    if (typeof input.privacyProtected === 'boolean') {
+        addFactor(factors, dimensions, 'contactability', 'Registration privacy is neutral; it does not establish contactability', 0);
+    }
+    const ageDays = finite(input.domainAgeDays);
+    if (ageDays !== null && ageDays >= 0) {
+        addFactor(factors, dimensions, 'registration', `Domain age (${formatAge(ageDays)}) is context only`, 0);
+    }
+    const rawScore = Math.round(factors.reduce((total, factor) => total + factor.delta, 0));
+    const score = Math.max(0, Math.min(100, rawScore));
+    const dimensionLabels = {
+        registration: 'Registration certainty',
+        listing: 'Listing readiness',
+        contactability: 'Contactability',
+        lifecycle: 'Lifecycle timing',
+    };
+    const observedFamilies = [...dimensions.keys()];
+    const evidenceQuality = buildScoreEvidenceQuality(input, {
+        expectedDepth: 'fast',
+        observedFamilies,
+        expectedFamilies: ['registration'],
+    });
+    return {
+        modelVersion: OPPORTUNITY_MODEL_VERSION,
+        score,
+        rawScore,
+        capped: score !== rawScore,
+        factors,
+        dimensions: [...dimensions.entries()].map(([id, contribution]) => ({ id, label: dimensionLabels[id], contribution })),
+        evidenceQuality,
+    };
+}
+export function computeOpportunityScore(value) {
+    return explainOpportunityScore(value)?.score ?? null;
+}
+export function opportunityTone(score) {
+    if (score === null)
+        return 'neutral';
+    if (score >= OPPORTUNITY_REVIEW_THRESHOLD)
+        return 'good';
+    if (score >= 40)
+        return 'neutral';
+    return 'warn';
+}

package/lib/page-fingerprints.mjs

@@ -430,7 +430,7 @@ function createPageFingerprints(html, options = {}) {
         || parsedStructure.structureLimitReached || text?.truncated === true || forms?.truncated === true
         || resourceHosts.truncated || identifiers.truncated;
     const limitations = [
-        'Fingerprints summarize capped static HTML and are comparison aids, not cryptographic proof of page authorship or intent.',
+        'Fingerprints summarise capped static HTML and are comparison aids, not cryptographic proof of page authorship or intent.',
         'Visible-text SimHash is a fuzzy similarity fingerprint and must not be treated as a cryptographic digest.',
         'DOM-structure SimHash is derived from a standards-compliant static token stream and is a review aid, not proof that two pages share an author or template.',
     ];

package/lib/page-language-signals.mjs

@@ -0,0 +1,124 @@
+// Reviewed, bounded language packs for static homepage text already retained by
+// Deep Lookup. Matching emits fixed labels only: no page phrase, surrounding
+// text, or arbitrary markup is returned or stored.
+import { analyzeStaticHtml, MAX_STATIC_HTML_CHARS, } from "./static-html-analysis.mjs";
+export const PAGE_LANGUAGE_SIGNAL_VERSION = 1;
+export const MAX_PAGE_LANGUAGE_SIGNAL_CHARS = MAX_STATIC_HTML_CHARS;
+const CONTROL_CHARACTER_RE = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/u;
+const CATEGORY_LABELS = Object.freeze({
+    account_verification: 'account-verification',
+    account_restriction: 'account-restriction',
+    payment_update: 'payment-update',
+    recovery_secret: 'wallet or recovery-secret',
+    urgent_action: 'urgent-action',
+});
+const PAGE_LANGUAGE_PACKS = Object.freeze([
+    {
+        id: 'en-reviewed-v1', language: 'en', label: 'English', patterns: [
+            { category: 'account_verification', expression: /(?:verify your account|confirm your identity|unusual (?:sign-?in|login) activity|click here to (?:verify|confirm|update|restore)|confirm your password)/iu },
+            { category: 'account_restriction', expression: /(?:account has been (?:suspended|limited|locked|restricted)|your account will be (?:suspended|closed|locked|terminated)|re-?activate your account|unauthorized access detected|your password (?:has expired|will expire soon))/iu },
+            { category: 'urgent_action', expression: /(?:security alert|immediate action required)/iu },
+            { category: 'payment_update', expression: /update your (?:payment|billing) (?:information|details)/iu },
+            { category: 'recovery_secret', expression: /(?:(?:connect|verify) your wallet|(?:enter|verify) your (?:seed|recovery) phrase|enter your private key)/iu },
+        ],
+    },
+    {
+        id: 'es-reviewed-v1', language: 'es', label: 'Spanish', patterns: [
+            { category: 'account_verification', expression: /(?:verifica (?:tu|su) cuenta|confirma (?:tu|su) identidad)/iu },
+            { category: 'account_restriction', expression: /(?:tu|su) cuenta (?:ha sido|será) (?:suspendida|bloqueada|limitada|restringida)/iu },
+            { category: 'urgent_action', expression: /(?:acción inmediata requerida|alerta de seguridad)/iu },
+            { category: 'payment_update', expression: /actualiza (?:tu|su) (?:información|datos) de pago/iu },
+            { category: 'recovery_secret', expression: /(?:introduce|ingrese) (?:tu|su) frase de recuperación/iu },
+        ],
+    },
+    {
+        id: 'fr-reviewed-v1', language: 'fr', label: 'French', patterns: [
+            { category: 'account_verification', expression: /(?:vérifiez votre compte|confirmez votre identité|veuillez confirmer votre identité)/iu },
+            { category: 'account_restriction', expression: /votre compte (?:a été|sera) (?:suspendu|bloqué|limité|restreint)/iu },
+            { category: 'urgent_action', expression: /(?:action immédiate requise|alerte de sécurité)/iu },
+            { category: 'payment_update', expression: /mettez à jour vos (?:informations|coordonnées) de paiement/iu },
+            { category: 'recovery_secret', expression: /saisissez votre phrase de récupération/iu },
+        ],
+    },
+    {
+        id: 'de-reviewed-v1', language: 'de', label: 'German', patterns: [
+            { category: 'account_verification', expression: /(?:bestätigen sie ihr konto|bestätigen sie ihre identität)/iu },
+            { category: 'account_restriction', expression: /ihr konto wurde (?:gesperrt|eingeschränkt|suspendiert)/iu },
+            { category: 'urgent_action', expression: /(?:sofortiges handeln erforderlich|sicherheitswarnung)/iu },
+            { category: 'payment_update', expression: /aktualisieren sie ihre zahlungsdaten/iu },
+            { category: 'recovery_secret', expression: /geben sie ihre wiederherstellungsphrase ein/iu },
+        ],
+    },
+    {
+        id: 'pt-reviewed-v1', language: 'pt', label: 'Portuguese', patterns: [
+            { category: 'account_verification', expression: /(?:verifique sua conta|confirme sua identidade)/iu },
+            { category: 'account_restriction', expression: /sua conta (?:foi|será) (?:suspensa|bloqueada|limitada|restrita)/iu },
+            { category: 'urgent_action', expression: /(?:ação imediata necessária|alerta de segurança)/iu },
+            { category: 'payment_update', expression: /atualize suas informações de pagamento/iu },
+            { category: 'recovery_secret', expression: /insira sua frase de recuperação/iu },
+        ],
+    },
+    {
+        id: 'it-reviewed-v1', language: 'it', label: 'Italian', patterns: [
+            { category: 'account_verification', expression: /(?:verifica il tuo account|conferma la tua identità)/iu },
+            { category: 'account_restriction', expression: /il tuo account (?:è stato|sarà) (?:sospeso|bloccato|limitato)/iu },
+            { category: 'urgent_action', expression: /(?:azione immediata richiesta|avviso di sicurezza)/iu },
+            { category: 'payment_update', expression: /aggiorna (?:i tuoi dati|le tue informazioni) di pagamento/iu },
+            { category: 'recovery_secret', expression: /inserisci la (?:tua )?frase di recupero/iu },
+        ],
+    },
+    {
+        id: 'nl-reviewed-v1', language: 'nl', label: 'Dutch', patterns: [
+            { category: 'account_verification', expression: /(?:verifieer uw account|bevestig uw identiteit)/iu },
+            { category: 'account_restriction', expression: /uw account (?:is|wordt) (?:geblokkeerd|beperkt|opgeschort)/iu },
+            { category: 'urgent_action', expression: /(?:onmiddellijke actie vereist|beveiligingswaarschuwing)/iu },
+            { category: 'payment_update', expression: /werk uw betalingsgegevens bij/iu },
+            { category: 'recovery_secret', expression: /voer uw herstelzin in/iu },
+        ],
+    },
+]);
+function preferredPacks(documentLanguage) {
+    if (typeof documentLanguage !== 'string')
+        return PAGE_LANGUAGE_PACKS;
+    const primary = documentLanguage.trim().toLowerCase().split('-', 1)[0];
+    if (!primary)
+        return PAGE_LANGUAGE_PACKS;
+    const declared = PAGE_LANGUAGE_PACKS.filter((pack) => pack.language === primary);
+    return declared.length
+        ? Object.freeze([...declared, ...PAGE_LANGUAGE_PACKS.filter((pack) => pack.language !== primary)])
+        : PAGE_LANGUAGE_PACKS;
+}
+export function detectPageLanguageSignal(input, documentLanguage, suppliedAnalysis) {
+    if (typeof input !== 'string' || !input || input.length > MAX_PAGE_LANGUAGE_SIGNAL_CHARS || CONTROL_CHARACTER_RE.test(input)) {
+        return null;
+    }
+    const analysis = suppliedAnalysis ?? analyzeStaticHtml(input, { includeVisibleText: true });
+    if (analysis.inputLimitReached || analysis.visibleTextLimitReached)
+        return null;
+    const visibleText = analysis.visibleText
+        .replace(/\s+/gu, ' ')
+        .trim();
+    if (!visibleText)
+        return null;
+    for (const pack of preferredPacks(documentLanguage)) {
+        for (const pattern of pack.patterns) {
+            if (!pattern.expression.test(visibleText))
+                continue;
+            return Object.freeze({
+                version: PAGE_LANGUAGE_SIGNAL_VERSION,
+                packId: pack.id,
+                language: pack.language,
+                category: pattern.category,
+                label: `Reviewed ${pack.label} ${CATEGORY_LABELS[pattern.category]} language`,
+            });
+        }
+    }
+    return null;
+}
+export function pageLanguagePackCatalogue() {
+    return Object.freeze(PAGE_LANGUAGE_PACKS.map((pack) => Object.freeze({
+        id: pack.id,
+        language: pack.language,
+        categories: Object.freeze([...new Set(pack.patterns.map((pattern) => pattern.category))]),
+    })));
+}

package/lib/rdap-capabilities.mjs

@@ -44,7 +44,7 @@ const EXTENSION_CATALOG = Object.freeze({
     farv1: {
         label: 'Federated authentication',
         category: 'standard',
-        capability: 'Federated authorization profile declaration.',
+        capability: 'Federated authorisation profile declaration.',
     },
     fred: {
         label: 'Registry-system extension',
@@ -111,7 +111,7 @@ const EXTENSION_CATALOG = Object.freeze({
     paging: {
         label: 'Result paging',
         category: 'standard',
-        capability: 'Paged search-result behavior.',
+        capability: 'Paged search-result behaviour.',
     },
     platformns: {
         label: 'Nameserver platform extension',
@@ -146,17 +146,17 @@ const EXTENSION_CATALOG = Object.freeze({
     rirsearch1: {
         label: 'Address-registry search',
         category: 'standard',
-        capability: 'Versioned network and autonomous-system search behavior.',
+        capability: 'Versioned network and autonomous-system search behaviour.',
     },
     sorting: {
         label: 'Result sorting',
         category: 'standard',
-        capability: 'Sorted search-result behavior.',
+        capability: 'Sorted search-result behaviour.',
     },
     subsetting: {
         label: 'Partial response',
         category: 'standard',
-        capability: 'Field-subset response behavior.',
+        capability: 'Field-subset response behaviour.',
     },
     ttl0: {
         label: 'DNS TTL extension',
@@ -270,7 +270,7 @@ export function inspectRdapCapabilities(parsedValue, status) {
         .map((entry) => entry.identifier)
         .slice(0, MAX_RDAP_UNKNOWN_CAPABILITIES);
     const limitations = [
-        'Declarations describe what the server claims for this response; they do not prove that an operation is authorized, implemented correctly, complete, or available anonymously.',
+        'Declarations describe what the server claims for this response; they do not prove that an operation is authorised, implemented correctly, complete, or available anonymously.',
         'Unknown identifiers remain visible and neutral. Catalogue recognition never affects availability or Risk scoring.',
     ];
     if (state === 'unavailable') {

package/lib/rdap-search-workbench.mjs

@@ -2,10 +2,16 @@ const RDAP_SEARCH_WORKBENCH_SCHEMA = 'whoisleuth.rdap-search-workbench';
 const RDAP_SEARCH_WORKBENCH_VERSION = 1;
 const MAX_HELP_ENTRIES = 64;
 const MAX_QUERY_VALUE_LENGTH = 254;
-const SEARCHABLE_RESOURCE_TYPES = new Set(['domains', 'nameservers', 'entities', 'ips', 'autnums']);
-const RELATED_RESOURCE_TYPES = new Set(['domains', 'nameservers', 'entities', 'ips', 'autnums']);
+const SEARCHABLE_RESOURCE_TYPES = new Set(['domains', 'nameservers', 'entities']);
+const RELATED_RESOURCE_TYPES = new Set(['entity']);
 const RECOGNIZED_PROPERTIES = new Set(['handle', 'fn', 'email', 'role']);
 const SENSITIVE_PROPERTIES = new Set(['fn', 'email']);
+const REGISTERED_PROPERTY_PATHS = Object.freeze({
+    email: Object.freeze(["$.entities[*].vcardArray[1][?(@[0]=='email')][3]"]),
+    fn: Object.freeze(["$.entities[*].vcardArray[1][?(@[0]=='fn')][3]"]),
+    handle: Object.freeze(['$.entities[*].handle']),
+    role: Object.freeze(['$.entities[*].roles']),
+});
 function record(value) {
     return value && typeof value === 'object' && !Array.isArray(value)
         ? value
@@ -136,14 +142,13 @@ function planRdapReverseSearch(help, requested) {
             limitation: 'The supplied help response did not advertise this exact reverse-search tuple.',
         });
     }
-    const parameter = `${relatedResourceType}_${property}`;
     const contactDisclosure = capability.disclosure === 'contact';
     return Object.freeze({
         schema: RDAP_SEARCH_WORKBENCH_SCHEMA,
         version: RDAP_SEARCH_WORKBENCH_VERSION,
         state: 'ready',
-        requestPath: `/${searchableResourceType}`,
-        query: Object.freeze({ [parameter]: value }),
+        requestPath: `/${searchableResourceType}/reverse_search/${relatedResourceType}`,
+        query: Object.freeze({ [property]: value }),
         disclosure: Object.freeze({
             class: capability.disclosure,
             summary: contactDisclosure
@@ -154,4 +159,89 @@ function planRdapReverseSearch(help, requested) {
         limitation: 'This is an offline request plan. It neither sends the query nor establishes result authority, completeness, or currentness.',
     });
 }
-export { MAX_HELP_ENTRIES, MAX_QUERY_VALUE_LENGTH, RDAP_SEARCH_WORKBENCH_SCHEMA, RDAP_SEARCH_WORKBENCH_VERSION, normalizeRdapSearchHelp, planRdapReverseSearch, };
+function inspectRdapReverseSearchResponse(value, requestedProperties = []) {
+    const document = record(value);
+    if (!document) {
+        return Object.freeze({
+            schema: RDAP_SEARCH_WORKBENCH_SCHEMA,
+            version: RDAP_SEARCH_WORKBENCH_VERSION,
+            state: 'invalid',
+            mappings: Object.freeze([]),
+            missingProperties: Object.freeze([]),
+            rejectedCount: 0,
+            truncated: false,
+            limitations: Object.freeze(['The reverse-search response was not an object.']),
+        });
+    }
+    const requested = [...new Set(requestedProperties
+            .map(boundedToken)
+            .filter((property) => Boolean(property)))]
+        .slice(0, RECOGNIZED_PROPERTIES.size);
+    const raw = document.reverse_search_properties_mapping;
+    if (!Array.isArray(raw)) {
+        return Object.freeze({
+            schema: RDAP_SEARCH_WORKBENCH_SCHEMA,
+            version: RDAP_SEARCH_WORKBENCH_VERSION,
+            state: 'invalid',
+            mappings: Object.freeze([]),
+            missingProperties: Object.freeze(requested),
+            rejectedCount: raw === undefined ? 0 : 1,
+            truncated: false,
+            limitations: Object.freeze([
+                'The response did not provide a valid reverse-search property mapping, so its result fields cannot be reconciled with the requested predicates.',
+            ]),
+        });
+    }
+    const mappings = [];
+    const seen = new Set();
+    let rejectedCount = 0;
+    const truncated = raw.length > MAX_HELP_ENTRIES;
+    for (const entry of raw.slice(0, MAX_HELP_ENTRIES)) {
+        const candidate = record(entry);
+        const property = boundedToken(candidate?.property);
+        const propertyPath = typeof candidate?.propertyPath === 'string'
+            ? candidate.propertyPath.trim().slice(0, 512)
+            : '';
+        if (!property || !propertyPath || /[\x00-\x1f\x7f]/u.test(propertyPath)) {
+            rejectedCount += 1;
+            continue;
+        }
+        const key = `${property}\u0000${propertyPath}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        mappings.push(Object.freeze({
+            property,
+            propertyPath,
+            state: REGISTERED_PROPERTY_PATHS[property]?.includes(propertyPath)
+                ? 'registered'
+                : 'unrecognized',
+        }));
+    }
+    if (truncated)
+        rejectedCount += raw.length - MAX_HELP_ENTRIES;
+    const mappedProperties = new Set(mappings.map((mapping) => mapping.property));
+    const missingProperties = requested.filter((property) => !mappedProperties.has(property));
+    const limitations = [];
+    if (missingProperties.length) {
+        limitations.push(`The response omitted mappings for requested properties: ${missingProperties.join(', ')}.`);
+    }
+    if (mappings.some((mapping) => mapping.state === 'unrecognized')) {
+        limitations.push('At least one mapping differs from the locally reviewed IANA registration and requires manual specification review.');
+    }
+    if (rejectedCount)
+        limitations.push(`${rejectedCount} malformed or excess mapping entr${rejectedCount === 1 ? 'y was' : 'ies were'} not used.`);
+    if (!mappings.length)
+        limitations.push('No usable reverse-search property mapping was retained.');
+    return Object.freeze({
+        schema: RDAP_SEARCH_WORKBENCH_SCHEMA,
+        version: RDAP_SEARCH_WORKBENCH_VERSION,
+        state: mappings.length && !limitations.length ? 'complete' : mappings.length ? 'partial' : 'invalid',
+        mappings: Object.freeze(mappings),
+        missingProperties: Object.freeze(missingProperties),
+        rejectedCount,
+        truncated,
+        limitations: Object.freeze(limitations),
+    });
+}
+export { MAX_HELP_ENTRIES, MAX_QUERY_VALUE_LENGTH, RDAP_SEARCH_WORKBENCH_SCHEMA, RDAP_SEARCH_WORKBENCH_VERSION, normalizeRdapSearchHelp, planRdapReverseSearch, inspectRdapReverseSearchResponse, };

package/lib/registry-access.mjs

@@ -3,7 +3,7 @@ const REGISTRY_ACCESS_PROFILE_LABELS = Object.freeze({
     'iana-referral': 'IANA referral discovery',
     'no-iana-service': 'No service published by IANA',
     'registry-policy-restricted': 'Registry policy restricted',
-    'source-ip-authorization-required': 'Source-IP authorization required',
+    'source-ip-authorization-required': 'Source-IP authorisation required',
 });
 const WHOIS_REGISTRY_ACCESS_PROFILES = new Set([
     'iana-referral',

package/lib/registry-capability-catalogue.mjs

@@ -51,9 +51,9 @@ const REGISTRY_STANDARDS_COVERAGE_SNAPSHOT = Object.freeze({
     ]),
     interpretation: 'This official-source snapshot describes published service coverage at the verification date. It does not test current reachability or decide registration, availability, ownership, safety, or maliciousness.',
 });
-const DISCOVERY_LIMITATION = 'IANA discovery is available, but no suffix-specific query, encoding, or parser behavior is fixture-verified.';
+const DISCOVERY_LIMITATION = 'IANA discovery is available, but no suffix-specific query, encoding, or parser behaviour is fixture-verified.';
 const FIXTURE_LIMITATION = 'Synthetic fixtures verify the current parser profile; they do not prove current live-registry reachability, policy, or field publication.';
-const ES_ACCESS_LIMITATION = 'The registry WHOIS service requires advance source-IP authorization. A failed or unavailable query is not evidence that the domain is unregistered.';
+const ES_ACCESS_LIMITATION = 'The registry WHOIS service requires advance source-IP authorisation. A failed or unavailable query is not evidence that the domain is unregistered.';
 const SWITCH_ACCESS_LIMITATION = 'The registry directs public domain searches to its official lookup. Its non-standard-port Domain Check is not integrated, and IANA publishes no RDAP service. Missing registry data is not evidence that the domain is unregistered.';
 const VN_ACCESS_LIMITATION = 'IANA publishes no domain WHOIS or RDAP service for this suffix. The official browser lookup is not integrated, and missing registry data is not evidence that the domain is unregistered.';
 const UK_TRANSITION_LIMITATION = 'Synthetic fixtures verify the documented sectioned port-43 response while that WHOIS service is phased out. RDAP remains the preferred registry source, and fixture coverage does not prove current reachability or field publication.';
@@ -64,8 +64,8 @@ const SHARED_WHOIS_NO_RDAP_LIMITATION = 'Synthetic fixture reuse is limited to a
 const WHOIS_ONLY_FIXTURE_LIMITATION = 'Synthetic fixtures verify the current WHOIS parser profile. IANA publishes no RDAP bootstrap service for this suffix, and missing registry data is not evidence that the domain is unregistered.';
 const NEGATIVE_ONLY_FIXTURE_LIMITATION = 'Synthetic fixtures verify only the authoritative no-record dialect; registered-field compatibility is not claimed, and fixture coverage does not prove current live-registry reachability or policy.';
 const WHOIS_ONLY_NEGATIVE_FIXTURE_LIMITATION = 'Synthetic fixtures verify only the authoritative WHOIS no-record dialect; registered-field compatibility is not claimed, IANA publishes no RDAP bootstrap service, and missing registry data is not evidence that the domain is unregistered.';
-const UNVERIFIED_WHOIS_REFERRAL_LIMITATION = 'IANA publishes a domain WHOIS referral, but its response behavior is not fixture-verified. A failed, restricted, prohibited, reserved, or otherwise inconclusive response is not evidence that the domain is unregistered, and IANA publishes no RDAP bootstrap service for this suffix.';
-const UNVERIFIED_WHOIS_WITH_RDAP_LIMITATION = 'IANA publishes domain WHOIS and RDAP discovery, but the WHOIS response behavior is not fixture-verified. A failed, restricted, prohibited, reserved, or otherwise inconclusive WHOIS response is not evidence that the domain is unregistered; RDAP remains separately attributed.';
+const UNVERIFIED_WHOIS_REFERRAL_LIMITATION = 'IANA publishes a domain WHOIS referral, but its response behaviour is not fixture-verified. A failed, restricted, prohibited, reserved, or otherwise inconclusive response is not evidence that the domain is unregistered, and IANA publishes no RDAP bootstrap service for this suffix.';
+const UNVERIFIED_WHOIS_WITH_RDAP_LIMITATION = 'IANA publishes domain WHOIS and RDAP discovery, but the WHOIS response behaviour is not fixture-verified. A failed, restricted, prohibited, reserved, or otherwise inconclusive WHOIS response is not evidence that the domain is unregistered; RDAP remains separately attributed.';
 const NORID_CLOSED_SUFFIX_LIMITATION = 'The registry has not opened this suffix for registrations, and IANA publishes no domain WHOIS or RDAP service. Missing registry data is contextual only and must not be interpreted as a live availability result.';
 const MIL_ACCESS_LIMITATION = 'IANA publishes no public domain WHOIS or RDAP service for this sponsored suffix. Missing registry data is contextual only and is not evidence that a name is unregistered or available.';
 const ARPA_ACCESS_LIMITATION = 'This infrastructure suffix is not ordinary public registration space. IANA publishes WHOIS metadata but no RDAP bootstrap service, and missing or non-domain-shaped data must not be interpreted as registration availability.';

package/lib/registry-insights.mjs

@@ -83,7 +83,7 @@ function disclosure(source, parsedValue, status) {
         return {
             source,
             state: 'unavailable',
-            detail: 'The source did not provide a usable normalized publication.',
+            detail: 'The source did not provide a usable normalised publication.',
         };
     }
     const parsed = record(parsedValue);
@@ -211,11 +211,11 @@ function publicationDiagnostic(source, parsedValue, status, observedAt) {
     if (parsed.serverTruncated === true)
         issues.push('The RDAP server declared a truncated response.');
     if (parsed.entitiesTruncated === true)
-        issues.push('The normalized entity inventory was capped.');
+        issues.push('The normalised entity inventory was capped.');
     if (parsed.statusesTruncated === true)
-        issues.push('The normalized status inventory was capped.');
+        issues.push('The normalised status inventory was capped.');
     if (strings(parsed.fieldsTruncated, 20).length)
-        issues.push('One or more normalized WHOIS fields were capped.');
+        issues.push('One or more normalised WHOIS fields were capped.');
     if (parsed.chainStatus === 'partial')
         issues.push('The WHOIS referral chain was incomplete or conflicting.');
     const conformance = strings(parsed.conformance, 30);
@@ -306,9 +306,9 @@ export function buildRegistryInsights(input) {
                 : unavailableCount
                     ? 'The comparison is partial because at least one publication was unavailable or incomplete.'
                     : sourceOnlyCount || redactedCount
-                        ? 'The sources differ in publication or disclosure without a normalized conflict.'
+                        ? 'The sources differ in publication or disclosure without a normalised conflict.'
                         : counts.equivalent
-                            ? 'The comparable fields are normalized as equivalent.'
+                            ? 'The comparable fields are normalised as equivalent.'
                             : 'No comparable fields were available.',
         },
         publications: [