From 254cc2b661f86a062569eafa06ae4fc7338d5c3b Mon Sep 17 00:00:00 2001
From: Uzair Akbar <uzairakbar025@gmail.com>
Date: Tue, 24 Mar 2026 11:38:04 -0400
Subject: [PATCH 1/4] Add code lookup page

---
 src/pages/code-lookup/CodeLookupPage.css     | 73 ++++++++++++++++
 src/pages/code-lookup/CodeLookupPage.tsx     | 21 +++++
 src/pages/code-lookup/CodeLookupPageBody.tsx | 89 ++++++++++++++++++++
 3 files changed, 183 insertions(+)
 create mode 100644 src/pages/code-lookup/CodeLookupPage.css
 create mode 100644 src/pages/code-lookup/CodeLookupPage.tsx
 create mode 100644 src/pages/code-lookup/CodeLookupPageBody.tsx

diff --git a/src/pages/code-lookup/CodeLookupPage.css b/src/pages/code-lookup/CodeLookupPage.css
new file mode 100644
index 000000000..41083e840
--- /dev/null
+++ b/src/pages/code-lookup/CodeLookupPage.css
@@ -0,0 +1,73 @@
+.code-lookup-container {
+    max-width: 900px;
+    margin: 0 auto;
+    padding: 2em 1.5em;
+}
+
+.code-lookup-container h2 {
+    margin-top: 0;
+}
+
+.code-lookup-textareas {
+    display: flex;
+    gap: 1em;
+    margin-top: 1em;
+}
+
+@media (max-width: 640px) {
+    .code-lookup-textareas {
+        flex-direction: column;
+    }
+}
+
+.code-lookup-column {
+    flex: 1;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5em;
+}
+
+.code-lookup-column label {
+    font-weight: 600;
+}
+
+.code-lookup-textarea {
+    width: 100%;
+    min-height: 220px;
+    font-family: 'Courier New', Courier, monospace;
+    font-size: 0.95em;
+    line-height: 1.6;
+    padding: 0.75em;
+    border: 1px solid var(--color-text-secondary);
+    border-radius: 6px;
+    background-color: var(--color-background);
+    color: var(--color-text);
+    resize: vertical;
+    box-sizing: border-box;
+}
+
+.code-lookup-textarea:focus {
+    outline: 2px solid var(--color-button-primary);
+    border-color: var(--color-button-primary);
+}
+
+.code-lookup-textarea[readonly] {
+    background-color: color-mix(in srgb, var(--color-button-secondary), var(--color-background) 50%);
+}
+
+.code-lookup-actions {
+    display: flex;
+    gap: 0.75em;
+    margin-top: 1em;
+    flex-wrap: wrap;
+}
+
+.code-lookup-status {
+    margin-top: 1em;
+    font-size: 0.9em;
+    color: var(--color-text-secondary);
+}
+
+.code-lookup-status .warning {
+    color: var(--color-text-orange);
+}
\ No newline at end of file
diff --git a/src/pages/code-lookup/CodeLookupPage.tsx b/src/pages/code-lookup/CodeLookupPage.tsx
new file mode 100644
index 000000000..251a4f766
--- /dev/null
+++ b/src/pages/code-lookup/CodeLookupPage.tsx
@@ -0,0 +1,21 @@
+import React, { Suspense } from 'react';
+
+import Loading from '@widgets/Loading';
+
+const PageParamsProvider = React.lazy(() => import('@features/params/PageParamsProvider'));
+const DataProvider = React.lazy(() => import('@features/data/context/DataProvider'));
+const CodeLookupPageBody = React.lazy(() => import('./CodeLookupPageBody'));
+
+const CodeLookupPage: React.FC = () => {
+    return (
+        <Suspense fallback={<Loading />}>
+            <PageParamsProvider>
+                <DataProvider>
+                    <CodeLookupPageBody />
+                </DataProvider>
+            </PageParamsProvider>
+        </Suspense>
+    );
+};
+
+export default CodeLookupPage;
diff --git a/src/pages/code-lookup/CodeLookupPageBody.tsx b/src/pages/code-lookup/CodeLookupPageBody.tsx
new file mode 100644
index 000000000..a71e04375
--- /dev/null
+++ b/src/pages/code-lookup/CodeLookupPageBody.tsx
@@ -0,0 +1,89 @@
+import { useDataContext } from '@features/data/context/useDataContext';
+import React, { useState } from 'react';
+import './CodeLookupPage.css';
+import { batchLookup, BatchMatchResult } from './batchMatchLogic';
+
+const CodeLookupPageBody: React.FC = () => {
+    const { languagesInSelectedSource } = useDataContext();
+    const [inputText, setInputText] = useState('');
+    const [outputText, setOutputText] = useState('');
+    const [statusMessages, setStatusMessages] = useState<string[]>([]);
+    const [copied, setCopied] = useState(false);
+
+    const isLoading = languagesInSelectedSource.length === 0;
+
+    function handleLookup() {
+        const lines = inputText.split('\n');
+        const results: BatchMatchResult[] = batchLookup(lines, languagesInSelectedSource);
+
+        const codes = results.map((r) => r.code);
+        setOutputText(codes.join('\n'));
+
+        const warnings: string[] = [];
+        results.forEach((r, i) => {
+            if (r.warning) {
+                warnings.push(`Line ${i + 1}: ${r.warning}`);
+            }
+        });
+        setStatusMessages(warnings);
+        setCopied(false);
+    }
+
+    async function handleCopy() {
+        try {
+            await navigator.clipboard.writeText(outputText);
+            setCopied(true);
+            setTimeout(() => setCopied(false), 2000);
+        } catch { }
+    }
+
+    return (
+        <div className="code-lookup-container">
+            <h2>Language Code Lookup</h2>
+            <p>
+                Enter language names below (one per line) and click <strong>Look Up</strong> to get their
+                language codes. Example: <code>Punjabi</code> &gt;&gt; <code>lah/pan</code>.
+            </p>
+            <div className="code-lookup-textareas">
+                <div className="code-lookup-column">
+                    <label htmlFor="batch-input">Language Names</label>
+                    <textarea
+                        id="batch-input"
+                        className="code-lookup-textarea"
+                        placeholder={'Example:\nUrdu\nPunjabi\nHindko'}
+                        value={inputText}
+                        onChange={(e) => setInputText(e.target.value)}
+                    />
+                </div>
+                <div className="code-lookup-column">
+                    <label htmlFor="batch-output">Language Codes</label>
+                    <textarea
+                        id="batch-output"
+                        className="code-lookup-textarea"
+                        readOnly
+                        value={outputText}
+                    />
+                </div>
+            </div>
+            <div className="code-lookup-actions">
+                <button className="primary" onClick={handleLookup} disabled={isLoading || inputText.trim() === ''}>
+                    {isLoading ? 'Loading data...' : 'Look Up'}
+                </button>
+                {outputText && (
+                    <button onClick={handleCopy}>{copied ? 'Copied!' : 'Copy Output'}</button>
+                )}
+            </div>
+            {statusMessages.length > 0 && (
+                <div className="code-lookup-status">
+                    {statusMessages.map((msg, i) => (
+                        <div key={i} className="warning">
+                            {msg}
+                        </div>
+                    ))}
+                </div>
+            )}
+        </div>
+    );
+};
+
+export default CodeLookupPageBody;

From 1751e8aa181ac858dcecabce30de559684892207 Mon Sep 17 00:00:00 2001
From: Uzair Akbar <uzairakbar025@gmail.com>
Date: Tue, 24 Mar 2026 11:38:52 -0400
Subject: [PATCH 2/4] Add code lookup page to navbar

---
 src/app/PageRoutes.tsx     | 3 +++
 src/widgets/PageNavBar.tsx | 1 +
 2 files changed, 4 insertions(+)

diff --git a/src/app/PageRoutes.tsx b/src/app/PageRoutes.tsx
index f83d388d6..cf899558e 100644
--- a/src/app/PageRoutes.tsx
+++ b/src/app/PageRoutes.tsx
@@ -7,6 +7,7 @@ import DocsPage from '@pages/DocsPage';
 import IntroPage from '@pages/IntroPage';
 import LuckySearchPage from '@pages/LuckySearchPage';
 import PrivacyPolicyPage from '@pages/PrivacyPolicyPage';
+import CodeLookupPage from '@pages/code-lookup/CodeLookupPage';
 
 export default function PageRoutes() {
   return (
@@ -23,6 +24,7 @@ export default function PageRoutes() {
         <Route path={LangNavPageName.About} element={<AboutPage />} />
         <Route path={LangNavPageName.PrivacyPolicy} element={<PrivacyPolicyPage />} />
         <Route path={LangNavPageName.DataCoverage} element={<DataCoveragePage />} />
+        <Route path={LangNavPageName.Codes} element={<CodeLookupPage />} />
       </Routes>
     </>
   );
@@ -55,4 +57,5 @@ export enum LangNavPageName {
   About = 'about',
   PrivacyPolicy = 'privacy-policy',
   DataCoverage = 'data-coverage',
+  Codes = 'codes',
 }
diff --git a/src/widgets/PageNavBar.tsx b/src/widgets/PageNavBar.tsx
index d00205d3e..37d32a9bb 100644
--- a/src/widgets/PageNavBar.tsx
+++ b/src/widgets/PageNavBar.tsx
@@ -26,6 +26,7 @@ const PageNavBar: React.FC = () => {
       <NavBarLink path={'/' + LangNavPageName.Intro}>Intro</NavBarLink>
       <NavBarLink path={'/' + LangNavPageName.Data}>Data</NavBarLink>
       <NavBarLink path={'/' + LangNavPageName.Docs}>Docs</NavBarLink>
+      <NavBarLink path={'/' + LangNavPageName.Codes}>Codes</NavBarLink>
       <button
         className="primary"
         type="button"

From fec4d0673fcfe095eb8b3fd83f4006b49b87438f Mon Sep 17 00:00:00 2001
From: Uzair Akbar <uzairakbar025@gmail.com>
Date: Tue, 24 Mar 2026 11:39:41 -0400
Subject: [PATCH 3/4] Add basic lookup logic for language codes

---
 src/pages/code-lookup/batchMatchLogic.ts | 125 +++++++++++++++++++++++
 1 file changed, 125 insertions(+)
 create mode 100644 src/pages/code-lookup/batchMatchLogic.ts

diff --git a/src/pages/code-lookup/batchMatchLogic.ts b/src/pages/code-lookup/batchMatchLogic.ts
new file mode 100644
index 000000000..220421c19
--- /dev/null
+++ b/src/pages/code-lookup/batchMatchLogic.ts
@@ -0,0 +1,125 @@
+/**
+ * 1. reuse anyWordStartsWith from SearchBar to find mcandidate matches
+ * 2. score candidates by exact match > code match > scope > short code
+ * 3. if best match has macrolanguage parent > produce composite code (e.g. `lah/pan`)
+*/
+
+// Urdu
+// Punjabi
+// Hindko
+// Mewati
+
+import { LanguageData, LanguageScope } from '@entities/language/LanguageTypes';
+import { anyWordStartsWith, normalizeAccents } from '@shared/lib/stringUtils';
+
+
+export type BatchMatchResult = {
+    code: string;
+    languageName: string;
+    warning?: string;
+};
+
+
+
+export function findBestMatch(query: string, languages: LanguageData[]): BatchMatchResult {
+    const trimmed = query.trim();
+
+    if (trimmed === '') {
+        return { code: '', languageName: '' };
+    }
+
+    const normalizedQuery = normalizeAccents(trimmed.toLowerCase());
+
+    // 1. re-use anyWordStartsWith from SearchBar to find mcandidate matches
+    const matches = languages.filter((lang) =>
+        lang.names.some((name) => anyWordStartsWith(name, trimmed)),
+    );
+
+    if (matches.length === 0) {
+        return { code: '???', languageName: '', warning: `No match found for "${trimmed}"` };
+    }
+
+    // 2. score candidates by exact match > code match > scope > short code
+    const scored = matches.map((lang) => ({
+        lang,
+        score: scoreLang(lang, normalizedQuery),
+    }));
+    scored.sort((a, b) => b.score - a.score);
+
+    // 3. if best match has macrolanguage parent > produce composite code (e.g. `lah/pan`)
+    const best = scored[0].lang;
+    const code = buildCompositeCode(best);
+
+    const warning =
+        scored.length > 1 && scored[0].score === scored[1].score
+            ? `Multiple matches for "${trimmed}" (showing best)`
+            : undefined;
+
+    return { code, languageName: best.nameDisplay, warning };
+}
+
+
+// TODO: 
+
+
+export function batchLookup(queries: string[], languages: LanguageData[]): BatchMatchResult[] {
+    return queries.map((query) => findBestMatch(query, languages));
+}
+
+
+// TODO: try hamming/edit distance, maybe fuse.js ???
+function scoreLang(lang: LanguageData, normalizedQuery: string): number {
+    let score = 0;
+
+    // exact name match
+    const hasExactName = lang.names.some(
+        (name) => normalizeAccents(name.toLowerCase()) === normalizedQuery,
+    );
+    if (hasExactName) score += 100;
+
+    // // exact code match (e.g. `urd`) (???)
+    // if (lang.ID.toLowerCase() === normalizedQuery || lang.codeDisplay.toLowerCase() === normalizedQuery) {
+    //   score += 50;
+    // }
+
+    // prefer macrolanguage exact matches (`pus` >> `pus/pbu`)
+    if (hasExactName && isMacrolanguage(lang)) score += 20;
+
+    // prefer individual languages over dialects(?)
+    // (but less than macrolanguages that already got +20 above)
+    if (lang.scope === LanguageScope.Language) score += 10;
+
+    // prefer iso codes (3-letter) over glottocodes (8 chars)
+    if (lang.ID.length <= 3) score += 5;
+
+    return score;
+}
+
+
+function buildCompositeCode(lang: LanguageData): string {
+    const macroAncestor = findMacrolanguageAncestor(lang);
+    if (macroAncestor) {
+        return macroAncestor.ID + '/' + lang.ID;
+    }
+    return lang.ID;
+}
+
+
+function isMacrolanguage(lang: LanguageData): boolean {
+    return lang.scope === LanguageScope.Macrolanguage
+        || lang.ISO?.scope === LanguageScope.Macrolanguage;
+}
+
+
+function findMacrolanguageAncestor(lang: LanguageData): LanguageData | undefined {
+    let current = lang.parentLanguage;
+    let depth = 0;
+    while (current && depth < 10) {
+        if (isMacrolanguage(current)) {
+            return current;
+        }
+        current = current.parentLanguage;
+        depth++;
+    }
+    return undefined;
+}

From 9d65d009b8c40919a4cee22b075a6f037c1bd425 Mon Sep 17 00:00:00 2001
From: Uzair Akbar <uzairakbar025@gmail.com>
Date: Tue, 24 Mar 2026 11:41:40 -0400
Subject: [PATCH 4/4] Add census based accuracy eval for code lookup logic

---
 .../__tests__/batchMatchCensus.test.ts        | 284 ++++++++++++++++++
 1 file changed, 284 insertions(+)
 create mode 100644 src/pages/code-lookup/__tests__/batchMatchCensus.test.ts

diff --git a/src/pages/code-lookup/__tests__/batchMatchCensus.test.ts b/src/pages/code-lookup/__tests__/batchMatchCensus.test.ts
new file mode 100644
index 000000000..7d764262c
--- /dev/null
+++ b/src/pages/code-lookup/__tests__/batchMatchCensus.test.ts
@@ -0,0 +1,284 @@
+import { renderHook, waitFor } from '@testing-library/react';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as React from 'react';
+import { MemoryRouter } from 'react-router-dom';
+import { afterAll, beforeAll, describe, expect, it } from 'vitest';
+
+import * as DataProviderModule from '@features/data/context/DataProvider';
+const DataProvider = (DataProviderModule as any).DataProvider || (DataProviderModule as any).default;
+
+import * as UseDataContextModule from '@features/data/context/useDataContext';
+const useDataContext = (UseDataContextModule as any).useDataContext || (UseDataContextModule as any).default;
+
+import * as PageParamsModule from '@features/params/PageParamsProvider';
+const PageParamsProvider = (PageParamsModule as any).PageParamsProvider || (PageParamsModule as any).default;
+
+import { LanguageData } from '@entities/language/LanguageTypes';
+import { findBestMatch } from '../batchMatchLogic';
+
+
+const PUBLIC_DIR = path.resolve(__dirname, '../../../../public');
+const CENSUS_DIR = path.join(PUBLIC_DIR, 'data/census/official');
+
+
+function parseCensusTSV(filePath: string): Array<{ expectedCode: string; name: string }> {
+    const text = fs.readFileSync(filePath, 'utf-8');
+    const lines = text.split('\n');
+    const results: Array<{ expectedCode: string; name: string }> = [];
+
+    let pastHeader = false;
+
+    for (const line of lines) {
+        if (line.startsWith('#')) continue;
+
+        if (!pastHeader) {
+            pastHeader = true;
+            continue;
+        }
+
+        const parts = line.split('\t');
+        const code = parts[0]?.trim();
+        const name = parts[1]?.trim();
+
+        if (!code || !name) continue;
+        if (name.startsWith('#')) continue;
+        if (code === 'und' || code === 'mul' || code === 'zxx') continue;
+        if (name.includes('Sign')) continue;
+
+        results.push({ expectedCode: code, name });
+    }
+
+    return results;
+}
+
+
+function topByFrequency<T>(
+    items: T[],
+    keyFn: (item: T) => string,
+    topN: number,
+): Array<{ key: string; count: number; representative: T }> {
+    const groups = new Map<string, { count: number; representative: T }>();
+
+    for (const item of items) {
+        const key = keyFn(item);
+        const existing = groups.get(key);
+        if (existing) {
+            existing.count++;
+        } else {
+            groups.set(key, { count: 1, representative: item });
+        }
+    }
+
+    return [...groups.entries()]
+        .map(([key, { count, representative }]) => ({ key, count, representative }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, topN);
+}
+
+
+// extract the loaded LanguageData array
+function findLanguages(obj: any, visited = new Set()): any[] {
+    if (!obj || typeof obj !== 'object' || visited.has(obj)) return [];
+    visited.add(obj);
+
+    // check if Array of LanguageData
+    if (Array.isArray(obj) && obj.length > 1000 && obj[0] && 'ID' in obj[0] && 'names' in obj[0]) {
+        return obj;
+    }
+    // check if Map of LanguageData
+    if (obj instanceof Map && obj.size > 1000) {
+        const arr = Array.from(obj.values());
+        if (arr[0] && 'ID' in arr[0] && 'names' in arr[0]) return arr;
+    }
+    // recurse down
+    for (const key of Object.keys(obj)) {
+        const res = findLanguages(obj[key], visited);
+        if (res.length > 0) return res;
+    }
+    return [];
+}
+
+
+describe('Batch Match Census Accuracy Test', () => {
+    let languageArray: LanguageData[] = [];
+    const originalFetch = global.fetch;
+
+    beforeAll(async () => {
+        // 1. mock global fetch to read from filesystem
+        global.fetch = async (input: RequestInfo | URL, init?: RequestInit) => {
+            let urlStr = '';
+            if (typeof input === 'string') urlStr = input;
+            else if (input instanceof URL) urlStr = input.toString();
+            else if (typeof input === 'object' && 'url' in input) urlStr = (input as Request).url;
+            else urlStr = String(input);
+
+            const match = urlStr.match(/data\/.*$/); // capture 'data/languages.tsv'
+
+            if (match) {
+                const filePath = path.join(PUBLIC_DIR, match[0]);
+
+                if (fs.existsSync(filePath)) {
+                    const text = fs.readFileSync(filePath, 'utf-8');
+                    const isJson = filePath.endsWith('.json');
+                    return new Response(text, {
+                        status: 200,
+                        headers: { 'Content-Type': isJson ? 'application/json' : 'text/tab-separated-values' }
+                    });
+                } else {
+                    console.warn(`[Fetch Mock] Missing file: ${filePath}`);
+                    return new Response('Not found', { status: 404 });
+                }
+            }
+
+            if (urlStr.startsWith('http') && originalFetch) {
+                return originalFetch(input, init);
+            }
+            return new Response('Not found', { status: 404 });
+        };
+
+        // 2. render data inside headless component wrapper
+        const wrapper = ({ children }: { children: React.ReactNode }) =>
+            React.createElement(MemoryRouter, null,
+                React.createElement(PageParamsProvider, null,
+                    React.createElement(DataProvider, null, children)
+                )
+            );
+
+        const { result } = renderHook(() => useDataContext(), { wrapper });
+
+        // 3. wait to fetch and link the data
+        await waitFor(
+            () => {
+                const current = result.current;
+                const values = findLanguages(current);
+
+                expect(values.length).toBeGreaterThan(1000);
+                languageArray = values;
+            },
+            { timeout: 30000, interval: 1000 }
+        );
+    }, 45000);
+
+    afterAll(() => {
+        global.fetch = originalFetch;
+    });
+
+    it('should load local language data successfully', () => {
+        expect(languageArray.length).toBeGreaterThan(1000);
+    });
+
+    it('should evaluate census language names against findBestMatch logic', { timeout: 60000 }, () => {
+        let totalEntries = 0;
+        let exactMatches = 0;
+        let baseCodeMatches = 0;
+        let noMatches = 0;
+        const mismatches: Array<{ file: string; name: string; expected: string; got: string }> = [];
+        const baseMatches: Array<{ file: string; name: string; expected: string; got: string }> = [];
+
+        const censusFiles = fs.readdirSync(CENSUS_DIR).filter((f) => f.endsWith('.tsv'));
+
+        for (const file of censusFiles) {
+            const filePath = path.join(CENSUS_DIR, file);
+            const entries = parseCensusTSV(filePath);
+
+            for (const { expectedCode, name } of entries) {
+                totalEntries++;
+                const result = findBestMatch(name, languageArray);
+
+                if (result.code === expectedCode) {
+                    exactMatches++;
+                } else if (result.code === '???') {
+                    noMatches++;
+                    mismatches.push({ file, name, expected: expectedCode, got: '???' });
+                } else {
+                    const expectedBase = expectedCode.includes('/')
+                        ? expectedCode.split('/').pop()!
+                        : expectedCode;
+                    const gotBase = result.code.includes('/') ? result.code.split('/').pop()! : result.code;
+
+                    if (gotBase === expectedBase) {
+                        baseCodeMatches++;
+                        baseMatches.push({ file, name, expected: expectedCode, got: result.code });
+                    } else {
+                        mismatches.push({ file, name, expected: expectedCode, got: result.code });
+                    }
+                }
+            }
+        }
+
+        const wrongCount = totalEntries - exactMatches - baseCodeMatches - noMatches;
+        const fullMatchRate = ((exactMatches / totalEntries) * 100).toFixed(1);
+        const baseMatchRate = (((exactMatches + baseCodeMatches) / totalEntries) * 100).toFixed(1);
+        const noMatchRate = ((noMatches / totalEntries) * 100).toFixed(1);
+        const mismatchRate = ((wrongCount / totalEntries) * 100).toFixed(1);
+
+        const summaryRow = (label: string, count: number | string, note: string) =>
+            `  ${label.padEnd(26)}${String(count).padStart(7)}   ${note}`;
+
+        console.log('\n===========================================================');
+        console.log('           BATCH MATCH CENSUS ACCURACY REPORT');
+        console.log('===========================================================');
+        console.log(summaryRow('Census files tested:', censusFiles.length, ''));
+        console.log(summaryRow('Total entries:', totalEntries, ''));
+        console.log('-----------------------------------------------------------');
+        console.log(summaryRow('Exact matches:', exactMatches, `(${fullMatchRate}%)`));
+        console.log(summaryRow('Base code matches:', baseCodeMatches, '(macro prefix differs)'));
+        console.log(summaryRow('No match (???):', noMatches, `(${noMatchRate}%)`));
+        console.log(summaryRow('Wrong match:', wrongCount, `(${mismatchRate}%)`));
+        console.log('-----------------------------------------------------------');
+        console.log(summaryRow('Overall accuracy:', `${baseMatchRate}%`, '(exact + base code)'));
+        console.log('===========================================================');
+
+        const NAME_WIDTH = 28;
+        const CODE_WIDTH = 20;
+        const listRow = (count: number, name: string, expected: string, got?: string) => {
+            const namePart = `"${name}"`.padEnd(NAME_WIDTH);
+            const expectedPart = `expected: ${expected}`.padEnd(CODE_WIDTH);
+            return got !== undefined
+                ? `  x${String(count).padStart(3)}  ${namePart}  ${expectedPart}  got: ${got}`
+                : `  x${String(count).padStart(3)}  ${namePart}  expected: ${expected}`;
+        };
+
+        const wrongMismatches = mismatches.filter((m) => m.got !== '???');
+        if (wrongMismatches.length > 0) {
+            const top10Wrong = topByFrequency(
+                wrongMismatches,
+                (m) => `${m.name}|${m.expected}|${m.got}`,
+                10,
+            );
+            console.log('\n  TOP 10 WRONG MATCHES:');
+            console.log('  ---------------------------------------------------------');
+            top10Wrong.forEach(({ count, representative: { name, expected, got } }) => {
+                console.log(listRow(count, name, expected, got));
+            });
+        }
+
+        const noMatchEntries = mismatches.filter((m) => m.got === '???');
+        if (noMatchEntries.length > 0) {
+            const top10NoMatch = topByFrequency(noMatchEntries, (m) => `${m.name}|${m.expected}`, 10);
+            console.log('\n  TOP 10 NO MATCHES (???):');
+            console.log('  ---------------------------------------------------------');
+            top10NoMatch.forEach(({ count, representative: { name, expected } }) => {
+                console.log(listRow(count, name, expected));
+            });
+        }
+
+        if (baseMatches.length > 0) {
+            const top10Base = topByFrequency(
+                baseMatches,
+                (m) => `${m.name}|${m.expected}|${m.got}`,
+                10,
+            );
+            console.log('\n  TOP 10 PREFIX MISMATCHES (only base code correct):');
+            console.log('  ---------------------------------------------------------');
+            top10Base.forEach(({ count, representative: { name, expected, got } }) => {
+                console.log(listRow(count, name, expected, got));
+            });
+        }
+
+        console.log('\n');
+
+        expect(exactMatches + baseCodeMatches).toBeGreaterThan(0);
+    });
+});
\ No newline at end of file