@slicedearth/whoisleuth-cli 2.3.0 → 2.5.1

package/lib/page-fingerprints.mjs

@@ -3,10 +3,11 @@
 // those intermediate representations exist only long enough to derive a digest.
 import { createHash } from 'node:crypto';
 import { analyzeStaticHtml } from "./static-html-analysis.mjs";
-const PAGE_FINGERPRINT_VERSION = 1;
-const MAX_FINGERPRINT_SOURCE_BYTES = 300000;
+import { PAGE_FINGERPRINT_VERSION, PAGE_FINGERPRINT_PARSERS, PAGE_FINGERPRINT_TOKEN_LIMITS, } from "../packages/contracts/page-fingerprints.mjs";
+import { MAX_HOMEPAGE_BYTES } from "./outbound-request-bounds.mjs";
+const MAX_FINGERPRINT_SOURCE_BYTES = MAX_HOMEPAGE_BYTES;
 const MAX_FINGERPRINT_TAG_LENGTH = 4096;
-const MAX_FINGERPRINT_TOKENS = 4096;
+const MAX_FINGERPRINT_TOKENS = PAGE_FINGERPRINT_TOKEN_LIMITS[PAGE_FINGERPRINT_VERSION];
 const MAX_FINGERPRINT_ATTRIBUTES = 64;
 const MAX_VISIBLE_TEXT_TOKENS = 8192;
 const MAX_FORM_FINGERPRINTS = 50;
@@ -15,11 +16,6 @@ const MAX_RESOURCE_HOSTS = 30;
 const MAX_IDENTIFIER_VALUES = 30;
 const CONTROL_RE = /[\u0000-\u001f\u007f-\u009f]|\p{Default_Ignorable_Code_Point}/gu;
 const HAS_CONTROL_RE = /[\u0000-\u001f\u007f-\u009f]|\p{Default_Ignorable_Code_Point}/u;
-const COMMENT_RE = /<!--[\s\S]*?(?:-->|$)/g;
-const RAW_BODY_RE = /<(script|style|noscript|textarea|template)\b([^>]*)>[\s\S]*?(?:<\/\1\s*>|$)/gi;
-const MARKUP_TOKEN_RE = /<\/?[A-Za-z][A-Za-z0-9:-]*\b[^>]*>|[^<]+/g;
-const TAG_NAME_RE = /^<\s*(\/?)\s*([A-Za-z][A-Za-z0-9:-]*)/;
-const ATTRIBUTE_RE = /([^\s"'<>\/=]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'=<>`]+)))?/g;
 const WORD_RE = /[\p{L}\p{N}]+/gu;
 const URL_ATTRIBUTE_NAMES = new Set(['action', 'cite', 'data', 'formaction', 'href', 'poster', 'src']);
 const OMITTED_ATTRIBUTE_NAMES = new Set(['integrity', 'nonce', 'srcdoc', 'style', 'value']);
@@ -28,16 +24,12 @@ function sha256(value) {
     return createHash('sha256').update(value).digest('hex');
 }
 function boundedSource(html) {
-    const original = Buffer.from(typeof html === 'string' ? html : String(html || ''), 'utf8');
-    const truncated = original.length > MAX_FINGERPRINT_SOURCE_BYTES;
-    const bytes = truncated ? original.subarray(0, MAX_FINGERPRINT_SOURCE_BYTES) : original;
+    const supplied = typeof html === 'string' ? html : '';
+    const prefix = Buffer.from(supplied.slice(0, MAX_FINGERPRINT_SOURCE_BYTES), 'utf8');
+    const truncated = supplied.length > MAX_FINGERPRINT_SOURCE_BYTES || prefix.length > MAX_FINGERPRINT_SOURCE_BYTES;
+    const bytes = prefix.subarray(0, MAX_FINGERPRINT_SOURCE_BYTES);
     return { bytes, text: bytes.toString('utf8'), truncated };
 }
-function staticMarkup(html) {
-    return html
-        .replace(COMMENT_RE, ' ')
-        .replace(RAW_BODY_RE, '<$1$2></$1>');
-}
 function normalizedExactBodyHash(value) {
     if (!value || typeof value !== 'object')
         return null;
@@ -56,39 +48,6 @@ function normalizedExactBodyHash(value) {
         source: 'captured-response-bytes',
     };
 }
-function parseAttributes(tag) {
-    const start = tag.search(/\s/);
-    if (start === -1)
-        return { values: new Map(), truncated: false };
-    const values = new Map();
-    let truncated = false;
-    let match;
-    ATTRIBUTE_RE.lastIndex = 0;
-    while ((match = ATTRIBUTE_RE.exec(tag.slice(start)))) {
-        const name = match[1]?.toLowerCase();
-        if (!name)
-            continue;
-        if (values.has(name))
-            continue;
-        if (values.size >= MAX_FINGERPRINT_ATTRIBUTES) {
-            truncated = true;
-            break;
-        }
-        values.set(name, match[2] ?? match[3] ?? match[4] ?? '');
-    }
-    return { values, truncated };
-}
-function decodeStableEntities(text) {
-    const named = { amp: '&', apos: "'", gt: '>', lt: '<', nbsp: ' ', quot: '"' };
-    return text.replace(/&(?:#(\d{1,7})|#x([a-f0-9]{1,6})|([a-z]{2,8}));/gi, (whole, decimal, hex, name) => {
-        if (name)
-            return named[name.toLowerCase()] ?? whole.toLowerCase();
-        const point = Number.parseInt(decimal || hex, decimal ? 10 : 16);
-        if (!Number.isInteger(point) || point <= 0 || point > 0x10ffff || (point >= 0xd800 && point <= 0xdfff))
-            return ' ';
-        return String.fromCodePoint(point);
-    });
-}
 function looksRandom(value) {
     if (typeof value !== 'string')
         return false;
@@ -105,10 +64,27 @@ function reduceDynamicValues(value) {
         .replace(/\b\d{4}-\d{1,2}-\d{1,2}(?:[t\s]\d{1,2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:z|[+-]\d{2}:?\d{2})?)?\b/gi, '<time>')
         .replace(/\b\d{10,13}\b/g, '<time>')
         .replace(/\b[a-f0-9]{16,}\b/gi, '<id>')
-        .replace(/\b(?=[a-z0-9_-]{20,}\b)(?=[a-z0-9_-]*[a-z])(?=[a-z0-9_-]*\d)[a-z0-9_-]+\b/gi, '<id>');
+        .replace(/[a-z0-9_-]+/gi, (token) => {
+        // Visit each maximal token once. Repeated lookaheads at word boundaries
+        // rescan hyphenated text quadratically when a required digit is absent.
+        // Only hyphens are outside the former ASCII word-boundary match;
+        // underscores remain part of the identifier, including at either end.
+        let start = 0;
+        let end = token.length;
+        while (start < end && token[start] === '-')
+            start += 1;
+        while (end > start && token[end - 1] === '-')
+            end -= 1;
+        if (end - start < 20)
+            return token;
+        const identifier = token.slice(start, end);
+        return /[a-z]/i.test(identifier) && /\d/.test(identifier)
+            ? `${token.slice(0, start)}<id>${token.slice(end)}`
+            : token;
+    });
 }
 function normalizeText(value, maxLength = 512) {
-    const normalized = reduceDynamicValues(decodeStableEntities(String(value || '')))
+    const normalized = reduceDynamicValues(String(value || ''))
         .normalize('NFKC')
         .replace(CONTROL_RE, ' ')
         .replace(/\s+/g, ' ')
@@ -150,49 +126,33 @@ function normalizeAttribute(name, value, baseUrl) {
         return name;
     return normalized ? `${name}=${normalized}` : name;
 }
-function normalizedMarkupAndStructure(html, baseUrl) {
-    const markup = staticMarkup(html);
+function normalizedMarkupAndStructure(analysis, baseUrl) {
     const normalizedTokens = [];
-    const structureTokens = [];
+    const structureTokens = analysis.structureTokens;
     const visibleSegments = [];
-    let normalizedTruncated = false;
-    let structureTruncated = false;
+    let normalizedTruncated = analysis.structureLimitReached;
+    const structureTruncated = analysis.structureLimitReached;
     let attributesTruncated = false;
-    let oversizedTag = false;
-    let match;
-    MARKUP_TOKEN_RE.lastIndex = 0;
-    while ((match = MARKUP_TOKEN_RE.exec(markup))) {
-        const token = match[0];
-        if (token.startsWith('<')) {
-            if (token.length > MAX_FINGERPRINT_TAG_LENGTH) {
-                oversizedTag = true;
-                continue;
-            }
-            const nameMatch = token.match(TAG_NAME_RE);
-            const name = nameMatch?.[2]?.toLowerCase();
-            if (!nameMatch || !name)
-                continue;
-            const closing = Boolean(nameMatch[1]);
-            const selfClosing = !closing && (VOID_TAGS.has(name) || /\/\s*>$/.test(token));
-            const structure = closing ? `/${name}` : selfClosing ? `${name}/` : name;
-            if (structureTokens.length < MAX_FINGERPRINT_TOKENS)
-                structureTokens.push(structure);
-            else
-                structureTruncated = true;
+    const oversizedTag = analysis.elements.some((element) => element.attributesTruncated);
+    for (const token of analysis.tokens) {
+        if (token.kind !== 'text') {
             if (normalizedTokens.length >= MAX_FINGERPRINT_TOKENS) {
                 normalizedTruncated = true;
                 continue;
             }
-            if (closing) {
-                normalizedTokens.push(`</${name}>`);
+            if (token.kind === 'end') {
+                normalizedTokens.push(`</${token.name}>`);
                 continue;
             }
-            const parsed = parseAttributes(token);
-            if (parsed.truncated)
+            const element = token.element;
+            const name = element.name;
+            const selfClosing = element.html && VOID_TAGS.has(name);
+            if (element.attributesTruncated || element.attributes.length > MAX_FINGERPRINT_ATTRIBUTES)
                 attributesTruncated = true;
-            const attributes = [...parsed.values.entries()]
+            const values = new Map(element.attributes.slice(0, MAX_FINGERPRINT_ATTRIBUTES).map(({ name, value }) => [name, value]));
+            const attributes = [...values.entries()]
                 .map(([attributeName, value]) => {
-                const metaKey = name === 'meta' ? String(parsed.values.get('name') || parsed.values.get('property') || '') : '';
+                const metaKey = name === 'meta' ? String(values.get('name') || values.get('property') || '') : '';
                 if (attributeName === 'content' && /(?:csrf|nonce|session|token)/i.test(metaKey))
                     return null;
                 return normalizeAttribute(attributeName, value, baseUrl);
@@ -202,7 +162,7 @@ function normalizedMarkupAndStructure(html, baseUrl) {
             normalizedTokens.push(`<${name}${attributes.length ? ` ${attributes.join(' ')}` : ''}${selfClosing ? '/' : ''}>`);
             continue;
         }
-        const text = normalizeText(token, MAX_FINGERPRINT_SOURCE_BYTES);
+        const text = normalizeText(token.value, MAX_FINGERPRINT_SOURCE_BYTES);
         if (!text)
             continue;
         visibleSegments.push(text);
@@ -270,66 +230,55 @@ function formActionClass(value, baseUrl) {
         return 'external-insecure';
     return 'external';
 }
-function formStructureFingerprint(markup, baseUrl) {
-    const forms = [];
-    let current = null;
+function formStructureFingerprint(analysis, baseUrl) {
+    const formByElement = new Map();
+    const firstElementById = new Map();
     let formLimitReached = false;
     let controlLimitReached = false;
     let controls = 0;
-    let match;
-    MARKUP_TOKEN_RE.lastIndex = 0;
-    while ((match = MARKUP_TOKEN_RE.exec(markup))) {
-        const token = match[0];
-        if (!token.startsWith('<') || token.length > MAX_FINGERPRINT_TAG_LENGTH)
-            continue;
-        const nameMatch = token.match(TAG_NAME_RE);
-        const name = nameMatch?.[2]?.toLowerCase();
-        if (!nameMatch || !name)
-            continue;
-        const closing = Boolean(nameMatch[1]);
-        if (name === 'form') {
-            if (closing) {
-                if (current)
-                    forms.push(current);
-                current = null;
-                continue;
-            }
-            if (current)
-                forms.push(current);
-            if (forms.length >= MAX_FORM_FINGERPRINTS) {
+    for (const [index, element] of analysis.elements.entries()) {
+        const attributes = new Map(element.attributes.map(({ name, value }) => [name, value]));
+        const id = attributes.get('id');
+        if (id && !firstElementById.has(id))
+            firstElementById.set(id, index);
+        if (element.html && element.name === 'form') {
+            if (formByElement.size >= MAX_FORM_FINGERPRINTS) {
                 formLimitReached = true;
-                current = null;
                 continue;
             }
-            const attributes = parseAttributes(token).values;
             const rawMethod = normalizeText(attributes.get('method') || 'get', 20);
-            current = {
+            formByElement.set(index, {
                 method: /^[a-z]{1,20}$/.test(rawMethod) ? rawMethod : 'other',
                 action: formActionClass(attributes.get('action'), baseUrl),
                 controls: {},
-            };
+            });
+        }
+    }
+    for (const element of analysis.elements) {
+        const name = element.name;
+        if (!element.html || !['button', 'input', 'select', 'textarea'].includes(name))
             continue;
+        const attributes = new Map(element.attributes.map(({ name, value }) => [name, value]));
+        let owner = attributes.has('form') ? firstElementById.get(attributes.get('form')) ?? null : element.parent;
+        if (!attributes.has('form')) {
+            while (owner !== null && !formByElement.has(owner))
+                owner = analysis.elements[owner]?.parent ?? null;
         }
-        if (!current || closing || !['button', 'input', 'select', 'textarea'].includes(name))
+        const current = owner === null ? undefined : formByElement.get(owner);
+        if (!current)
             continue;
         if (controls >= MAX_FORM_CONTROLS) {
             controlLimitReached = true;
             continue;
         }
         controls += 1;
-        const attributes = parseAttributes(token).values;
         const rawType = name === 'input' || name === 'button'
             ? normalizeText(attributes.get('type') || (name === 'input' ? 'text' : 'submit'), 30)
             : name;
         const type = /^[a-z0-9-]{1,30}$/.test(rawType) ? `${name}:${rawType}` : `${name}:other`;
         current.controls[type] = (current.controls[type] || 0) + 1;
     }
-    if (current)
-        forms.push(current);
-    if (forms.length > MAX_FORM_FINGERPRINTS) {
-        forms.length = MAX_FORM_FINGERPRINTS;
-        formLimitReached = true;
-    }
+    const forms = [...formByElement.values()];
     for (const form of forms)
         form.controls = Object.fromEntries(Object.entries(form.controls).sort(([left], [right]) => left.localeCompare(right)));
     return forms.length ? {
@@ -337,7 +286,7 @@ function formStructureFingerprint(markup, baseUrl) {
         value: sha256(JSON.stringify(forms)),
         formCount: forms.length,
         controlCount: controls,
-        truncated: formLimitReached || controlLimitReached,
+        truncated: formLimitReached || controlLimitReached || analysis.tagLimitReached || analysis.inputLimitReached,
     } : null;
 }
 function normalizedResourceHosts(resources) {
@@ -418,21 +367,25 @@ function createPageFingerprints(html, options = {}) {
     };
     if (options.sourceTruncated === true && exact.scope === 'complete-body')
         exact = { ...exact, scope: 'captured-prefix' };
-    const normalized = normalizedMarkupAndStructure(source.text, baseUrl);
-    const parsedStructure = analyzeStaticHtml(source.text, { baseUrl });
+    const parsedStructure = !source.truncated && options.htmlAnalysis
+        ? options.htmlAnalysis : analyzeStaticHtml(source.text, { baseUrl, includeVisibleText: true });
+    const documentIncomplete = options.sourceTruncated === true || source.truncated
+        || parsedStructure.inputLimitReached || parsedStructure.tagLimitReached;
+    const treeIncomplete = documentIncomplete || parsedStructure.structureLimitReached;
+    const resolutionBase = parsedStructure.effectiveBaseUrl ?? baseUrl;
+    const normalized = normalizedMarkupAndStructure(parsedStructure, resolutionBase);
     const text = visibleTextFingerprint(normalized.visibleText);
     const structureSimilarity = simHash64(parsedStructure.structureTokens);
-    const forms = formStructureFingerprint(staticMarkup(source.text), baseUrl);
+    const forms = formStructureFingerprint(parsedStructure, resolutionBase);
     const resourceHosts = normalizedResourceHosts(options.resources);
     const identifiers = normalizedIdentifiers(options.trackingIdentifiers, options.identifiersTruncated === true);
-    const truncated = options.sourceTruncated === true || source.truncated || normalized.normalizedTruncated
-        || normalized.structureTruncated || parsedStructure.inputLimitReached || parsedStructure.tagLimitReached
-        || parsedStructure.structureLimitReached || text?.truncated === true || forms?.truncated === true
+    const truncated = treeIncomplete || normalized.normalizedTruncated
+        || normalized.structureTruncated || text?.truncated === true || forms?.truncated === true
         || resourceHosts.truncated || identifiers.truncated;
     const limitations = [
         '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.',
+        'DOM-structure and form fingerprints describe parsed ancestry and explicit form references, not every browser form-owner repair, executed behaviour or proof of a shared author.',
     ];
     if (source.truncated)
         limitations.push(`Fingerprint input was capped at ${MAX_FINGERPRINT_SOURCE_BYTES} UTF-8 bytes.`);
@@ -453,24 +406,24 @@ function createPageFingerprints(html, options = {}) {
             algorithm: 'sha256',
             value: sha256(normalized.normalizedTokens.join('\n')),
             tokenCount: normalized.normalizedTokens.length,
-            truncated: normalized.normalizedTruncated,
+            truncated: treeIncomplete || normalized.normalizedTruncated,
         },
-        visibleText: text,
+        visibleText: text ? { ...text, truncated: treeIncomplete || text.truncated } : null,
         domStructure: {
             algorithm: 'sha256',
             value: sha256(normalized.structureTokens.join('\n')),
             nodeCount: normalized.structureTokens.length,
-            parser: 'static-tag-sequence-v1',
-            truncated: normalized.structureTruncated,
+            parser: PAGE_FINGERPRINT_PARSERS[PAGE_FINGERPRINT_VERSION],
+            truncated: treeIncomplete || normalized.structureTruncated,
             similarity: structureSimilarity ? {
                 algorithm: 'simhash64-v1',
                 value: structureSimilarity.value,
                 tokenCount: parsedStructure.structureTokens.length,
                 featureCount: structureSimilarity.featureCount,
-                truncated: parsedStructure.inputLimitReached || parsedStructure.tagLimitReached || parsedStructure.structureLimitReached,
+                truncated: treeIncomplete,
             } : null,
         },
-        formStructure: forms,
+        formStructure: forms ? { ...forms, truncated: documentIncomplete || forms.truncated } : null,
         resourceHosts,
         identifiers,
         complete: !truncated,

package/lib/page-role-profile.mjs

@@ -24,13 +24,17 @@ function addFinding(findings, role, label, confidence, evidence) {
 }
 function analyzePageRole(input = {}) {
     const htmlAnalysis = input.htmlAnalysis ?? analyzeStaticHtml(input.html);
-    const markup = htmlAnalysis.markup;
+    const elements = htmlAnalysis.elements.filter((element) => element.html && element.name !== 'template');
+    // Reuse native element evidence instead of allocating and scanning a second,
+    // independently capped reconstruction of the same document.
+    const marker = (pattern) => elements.some((element) => pattern.test(element.name)
+        || element.attributes.some(({ name, value }) => pattern.test(name) || pattern.test(value.toLowerCase())));
     const title = boundedLowercase(input.pageTitle, MAX_ROLE_TITLE_CHARS);
     const activityStatus = boundedLowercase(input.activityStatus, 40);
     const forms = htmlAnalysis.forms;
     const findings = [];
     const challengeEvidence = [];
-    if (/(?:captcha|recaptcha|hcaptcha|turnstile|cf-chl|challenge-form|verify-human)/u.test(markup)) {
+    if (marker(/(?:captcha|recaptcha|hcaptcha|turnstile|cf-chl|challenge-form|verify-human)/u)) {
         challengeEvidence.push('Static challenge or human-verification marker observed');
     }
     if (/(?:just a moment|checking your browser|verify you are human|access denied)/u.test(title)) {
@@ -43,19 +47,19 @@ function analyzePageRole(input = {}) {
     if (forms.categories.username > 0 || forms.categories.email > 0) {
         authenticationEvidence.push('Username or email-purpose input observed');
     }
-    if (/(?:login|log-in|signin|sign-in|authentication|current-password|new-password)/u.test(markup)) {
+    if (marker(/(?:login|log-in|signin|sign-in|authentication|current-password|new-password)/u)) {
         authenticationEvidence.push('Static authentication marker observed');
     }
     addFinding(findings, 'authentication', 'Authentication', forms.categories.password > 0 ? 'high' : 'medium', authenticationEvidence);
     const commerceEvidence = [];
     if (forms.categories.payment > 0)
         commerceEvidence.push('Payment-purpose input observed');
-    if (/(?:checkout|shopping-cart|add-to-cart|product-price|woocommerce|shopify-payment)/u.test(markup)) {
+    if (marker(/(?:checkout|shopping-cart|add-to-cart|product-price|woocommerce|shopify-payment)/u)) {
         commerceEvidence.push('Static commerce or checkout marker observed');
     }
     addFinding(findings, 'commerce', 'Commerce', forms.categories.payment > 0 ? 'high' : 'medium', commerceEvidence);
     const supportEvidence = [];
-    if (/(?:contact|support|helpdesk|customer-service)/u.test(markup)) {
+    if (marker(/(?:contact|support|helpdesk|customer-service)/u)) {
         supportEvidence.push('Static support or contact marker observed');
     }
     if (forms.formsObserved > 0 && forms.categories.password === 0 && forms.categories.payment === 0) {
@@ -65,14 +69,14 @@ function analyzePageRole(input = {}) {
     const parkedEvidence = [];
     if (activityStatus === 'parked')
         parkedEvidence.push('Existing activity analysis classified the page as parked');
-    if (/(?:domain-for-sale|buy-this-domain|parking-page|sedoparking)/u.test(markup)) {
+    if (marker(/(?:domain-for-sale|buy-this-domain|parking-page|sedoparking)/u)) {
         parkedEvidence.push('Static domain-sale or parking marker observed');
     }
     addFinding(findings, 'parked_sale', 'Parked or for sale', activityStatus === 'parked' ? 'high' : 'medium', parkedEvidence);
     const contentEvidence = [];
-    if (/<(?:article|main)(?:\s|>)/u.test(markup))
+    if (elements.some(({ name }) => name === 'article' || name === 'main'))
         contentEvidence.push('Semantic article or main-content element observed');
-    if (/<(?:h1|h2)(?:\s|>)/u.test(markup))
+    if (elements.some(({ name }) => name === 'h1' || name === 'h2'))
         contentEvidence.push('Static heading structure observed');
     addFinding(findings, 'content', 'Content or publication', contentEvidence.length > 1 ? 'medium' : 'low', contentEvidence);
     if (!findings.length) {

package/lib/perceptual-hash-comparison.mjs

@@ -1,34 +1,2 @@
-// Browser-safe comparison contract for the 64-bit perceptual hashes produced
-// by the bounded image decoder. Keeping comparison and informativeness here
-// prevents Node and browser consumers from drifting into different matches.
-export const PERCEPTUAL_HASH_HEX_RE = /^[0-9a-f]{16}$/u;
-export const MIN_INFORMATIVE_HASH_BITS = 10;
-const POPCOUNT = new Uint8Array(16);
-for (let index = 0; index < POPCOUNT.length; index += 1) {
-    POPCOUNT[index] = (index & 1) + ((index >> 1) & 1) + ((index >> 2) & 1) + ((index >> 3) & 1);
-}
-export function isPerceptualHash(value) {
-    return typeof value === 'string' && PERCEPTUAL_HASH_HEX_RE.test(value);
-}
-function popcountHex(hex) {
-    let bits = 0;
-    for (let index = 0; index < hex.length; index += 1) {
-        bits += POPCOUNT[parseInt(hex.charAt(index), 16)] ?? 0;
-    }
-    return bits;
-}
-export function isInformativePerceptualHash(value) {
-    if (!isPerceptualHash(value))
-        return false;
-    const bits = popcountHex(value);
-    return bits >= MIN_INFORMATIVE_HASH_BITS && bits <= 64 - MIN_INFORMATIVE_HASH_BITS;
-}
-export function hammingDistanceHex(left, right) {
-    if (!isPerceptualHash(left) || !isPerceptualHash(right))
-        return null;
-    let distance = 0;
-    for (let index = 0; index < 16; index += 1) {
-        distance += POPCOUNT[parseInt(left.charAt(index), 16) ^ parseInt(right.charAt(index), 16)] ?? 0;
-    }
-    return distance;
-}
+// Retained public import; the runtime-neutral implementation lives in the domain layer.
+export * from "../packages/analysis/perceptual-hash-comparison.mjs";