// reconciliation-queue.jsx — Wave 2: Statement reconciliation + learning matcher
//
// One screen, two modes:
// • Queue view — all unmatched income lines across statements, grouped &
// sortable, with per-line confidence scores from the auto-matcher
// • Match drawer — pick the right Work/Recording for one line, see candidate
// matches with reasoning, save the decision; the matcher LEARNS from it
//
// Data flow:
// STMT_INDEX → flatten lines → run synthAutoMatch(line) → confidence + candidates
// → user accepts or overrides
// → matchRules[] is appended
// → next pass uses those rules
//
// Exports: window.ScreenReconciliation, window.ReconciliationQueue (component)
(function () {
const { useState, useMemo, useEffect } = React;
// ─────────── helpers ───────────
const fmt$ = (n) => '$' + (Number(n) || 0).toLocaleString('en-US', { maximumFractionDigits: 2, minimumFractionDigits: 2 });
const fmtInt = (n) => (Number(n) || 0).toLocaleString('en-US');
const norm = (s) => (s || '').toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
const tokens = (s) => norm(s).split(' ').filter(Boolean);
// Levenshtein-ish similarity (token Jaccard, fast & good enough for titles)
function titleSim(a, b) {
const A = new Set(tokens(a));
const B = new Set(tokens(b));
if (!A.size || !B.size) return 0;
let inter = 0;
A.forEach(t => B.has(t) && inter++);
return inter / new Set([...A, ...B]).size;
}
// ─────────── auto-matcher ───────────
// Given a line, returns { status, confidence, candidates, reasoning }
// status: matched | uncertain | unmatched
function autoMatch(line, ctx) {
// Delegate to MatcherEngine if loaded (mojibake-aware + phonetic +
// trigram + ID-partial + fractional). Falls back to legacy if not.
if (window.MatcherEngine) {
return window.MatcherEngine.matchOne(line, ctx);
}
const { recordings, works, rules } = ctx;
const candidates = [];
// 1) ISRC exact match → very high confidence
if (line.isrc) {
const r = recordings.find(x => (x.isrc || '').toUpperCase() === line.isrc.toUpperCase());
if (r) {
candidates.push({ kind:'recording', id:r.id, label:r.title || r.name, conf:0.99, reason:`ISRC ${line.isrc} exact match`, ref:r });
}
}
// 2) UPC → release → recordings
if (line.upc) {
const releases = window.RELEASES || [];
const rel = releases.find(x => (x.upc || '').replace(/\D/g,'') === line.upc.replace(/\D/g,''));
if (rel) {
candidates.push({ kind:'release', id:rel.id, label:rel.title || rel.name, conf:0.92, reason:`UPC ${line.upc} matches release "${rel.title||rel.name}"`, ref:rel });
}
}
// 3) Saved learning rule (token signature → asset)
const sig = makeSignature(line);
const ruleHit = rules.find(r => r.signature === sig);
if (ruleHit) {
candidates.push({ kind:ruleHit.kind, id:ruleHit.id, label:ruleHit.label, conf:0.95, reason:`Learned rule: same source/title pattern matched ${ruleHit.label} ${ruleHit.appliedCount}× before`, learned:true });
}
// 4) Title fuzzy → works (PRO/MLC statements)
const titleField = line.trackTitle || line.workTitle || line.title;
if (titleField) {
let best = null;
for (const w of works) {
const s = titleSim(titleField, w.title || w.name);
if (!best || s > best.s) best = { s, w };
}
if (best && best.s >= 0.6) {
candidates.push({ kind:'work', id:best.w.id, label:best.w.title || best.w.name, conf: 0.5 + best.s * 0.4, reason:`Title fuzzy match: "${titleField}" ↔ "${best.w.title||best.w.name}" (${(best.s*100).toFixed(0)}% token overlap)`, ref:best.w });
}
}
// 5) Artist + title combo for recordings
if (titleField && (line.trackArtists || line.releaseArtists)) {
const artist = line.trackArtists || line.releaseArtists;
let best = null;
for (const r of recordings) {
const ts = titleSim(titleField, r.title || r.name);
const as = titleSim(artist, r.primaryArtistName || r.artist || '');
const combined = ts * 0.7 + as * 0.3;
if (!best || combined > best.s) best = { s: combined, r };
}
if (best && best.s >= 0.55) {
candidates.push({ kind:'recording', id:best.r.id, label:best.r.title || best.r.name, conf: 0.4 + best.s * 0.4, reason:`Artist + title combo: "${titleField}" by ${artist} ↔ "${best.r.title||best.r.name}"`, ref:best.r });
}
}
// De-dupe by id, keep highest conf
const dedup = new Map();
for (const c of candidates) {
const k = c.kind + ':' + c.id;
if (!dedup.has(k) || dedup.get(k).conf < c.conf) dedup.set(k, c);
}
const sorted = [...dedup.values()].sort((a,b) => b.conf - a.conf);
const top = sorted[0];
let status = 'unmatched';
if (top) {
if (top.conf >= 0.85) status = 'matched';
else if (top.conf >= 0.55) status = 'uncertain';
}
return { status, confidence: top?.conf || 0, candidates: sorted, top };
}
// Signature: source kind + normalized title prefix + territory
function makeSignature(line) {
const t = norm(line.trackTitle || line.workTitle || line.title || '').slice(0, 32);
const src = (line.sourceKind || line.source || '').toLowerCase();
return `${src}|${t}|${line.territory || ''}`;
}
// ─────────── flatten statement lines into queue items ───────────
function flattenQueue(idx) {
const out = [];
if (!idx || !idx.statements) return out;
for (const stmt of idx.statements) {
for (const ln of stmt.lines || []) {
out.push({
...ln,
stmtId: stmt.id,
stmtSource: stmt.sourceName,
stmtSourceColor: stmt.sourceColor,
stmtSourceKind: stmt.sourceKind,
stmtPeriod: stmt.periodLabel || stmt.period,
stmtCurrency: stmt.currency || 'USD',
amountUsd: ln.royaltyUsd || ln.amountUsd || ln.amount || 0,
sourceKind: stmt.sourceKind,
});
}
}
return out;
}
// ─────────── persistent rules ───────────
function loadRules() {
try {
return JSON.parse(localStorage.getItem('astro.recon.rules') || '[]');
} catch { return []; }
}
function saveRules(rules) {
try { localStorage.setItem('astro.recon.rules', JSON.stringify(rules)); } catch {}
}
// ═══════════════════════════════════════════════════════ MAIN SCREEN
function ScreenReconciliation({ go }) {
const [stmtLoaded, setStmtLoaded] = useState(!!window.__STMT_LOADED);
useEffect(() => {
if (stmtLoaded) return;
const h = () => setStmtLoaded(true);
window.addEventListener('astro-statements-loaded', h);
return () => window.removeEventListener('astro-statements-loaded', h);
}, [stmtLoaded]);
const [rules, setRules] = useState(() => loadRules());
const [overrides, setOverrides] = useState(() => {
try { return JSON.parse(localStorage.getItem('astro.recon.overrides') || '{}'); } catch { return {}; }
});
const [filter, setFilter] = useState('uncertain'); // all | unmatched | uncertain | matched | mine
const [sourceFilter, setSourceFilter] = useState('all');
const [search, setSearch] = useState('');
const [activeIdx, setActiveIdx] = useState(null);
const [sortBy, setSortBy] = useState('amount-desc');
const recordings = window.RECORDINGS || [];
const works = window.WORKS || [];
const stmtIdx = window.__STMT_INDEX || { statements: [] };
const [thresholds, setThresholds] = useState(() => {
try { return JSON.parse(localStorage.getItem('astro.recon.thresholds') || '{}'); } catch { return {}; }
});
const queue = useMemo(() => {
const lines = flattenQueue(stmtIdx);
const ctx = { recordings, works, rules, thresholds };
// Apply manual overrides first; pass the rest through batch matcher
// so the cluster-pass can see all the unmatched lines together.
const annotated = lines.map(ln => ({ ...ln, key: ln.stmtId + ':' + ln.id }));
const overridden = annotated.filter(ln => overrides[ln.key]);
const fresh = annotated.filter(ln => !overrides[ln.key]);
let freshResults;
if (window.MatcherEngine) {
freshResults = window.MatcherEngine.matchBatch(fresh, ctx);
} else {
freshResults = fresh.map(ln => ({ line: ln, ...autoMatch(ln, ctx) }));
}
const out = [];
for (const ln of overridden) {
const ov = overrides[ln.key];
out.push({ ...ln, status: 'matched', confidence: 1, manual: true, match: ov, candidates: [ov], top: ov });
}
for (const r of freshResults) {
out.push({ ...r.line, status: r.status, confidence: r.confidence, candidates: r.candidates, top: r.top, match: r.top || null, cluster: r.cluster });
}
return out;
// eslint-disable-next-line react-hooks/exhaustive-deps
}, [stmtIdx.statements, rules, overrides, thresholds]);
const stats = useMemo(() => ({
total: queue.length,
matched: queue.filter(q => q.status === 'matched').length,
uncertain: queue.filter(q => q.status === 'uncertain').length,
unmatched: queue.filter(q => q.status === 'unmatched').length,
manual: queue.filter(q => q.manual).length,
totalUsd: queue.reduce((s, q) => s + (q.amountUsd || 0), 0),
unmatchedUsd: queue.filter(q => q.status !== 'matched').reduce((s, q) => s + (q.amountUsd || 0), 0),
}), [queue]);
const sources = useMemo(() => {
const set = new Map();
for (const q of queue) set.set(q.stmtSource, (set.get(q.stmtSource) || 0) + 1);
return [...set.entries()].sort((a,b) => b[1] - a[1]);
}, [queue]);
const filtered = useMemo(() => {
let arr = queue;
if (filter === 'unmatched') arr = arr.filter(q => q.status === 'unmatched');
else if (filter === 'uncertain') arr = arr.filter(q => q.status === 'uncertain');
else if (filter === 'matched') arr = arr.filter(q => q.status === 'matched');
else if (filter === 'mine') arr = arr.filter(q => q.manual);
if (sourceFilter !== 'all') arr = arr.filter(q => q.stmtSource === sourceFilter);
if (search) {
const s = norm(search);
arr = arr.filter(q => norm(q.trackTitle || q.workTitle || q.title || '').includes(s)
|| norm(q.trackArtists || q.releaseArtists || '').includes(s)
|| (q.isrc || '').toLowerCase().includes(s.toLowerCase()));
}
// Sort
if (sortBy === 'amount-desc') arr = [...arr].sort((a,b) => (b.amountUsd||0) - (a.amountUsd||0));
else if (sortBy === 'conf-asc') arr = [...arr].sort((a,b) => (a.confidence||0) - (b.confidence||0));
else if (sortBy === 'title') arr = [...arr].sort((a,b) => (a.trackTitle||'').localeCompare(b.trackTitle||''));
return arr;
}, [queue, filter, sourceFilter, search, sortBy]);
const active = activeIdx != null ? filtered[activeIdx] : null;
const acceptMatch = (line, candidate) => {
const newOverrides = { ...overrides, [line.key]: candidate };
setOverrides(newOverrides);
try { localStorage.setItem('astro.recon.overrides', JSON.stringify(newOverrides)); } catch {}
// Add learning rule if this is a manual selection
const sig = makeSignature(line);
const existing = rules.find(r => r.signature === sig);
if (existing) {
existing.appliedCount = (existing.appliedCount || 1) + 1;
existing.lastApplied = new Date().toISOString();
} else {
rules.push({
signature: sig,
kind: candidate.kind,
id: candidate.id,
label: candidate.label,
createdAt: new Date().toISOString(),
lastApplied: new Date().toISOString(),
appliedCount: 1,
source: line.stmtSource,
});
}
const newRules = [...rules];
setRules(newRules);
saveRules(newRules);
// Move to next uncertain
const remaining = filtered.filter((_, i) => i !== activeIdx);
if (remaining.length > 0) setActiveIdx(Math.min(activeIdx, remaining.length - 1));
else setActiveIdx(null);
};
const rejectAndQuarantine = (line) => {
const newOverrides = { ...overrides, [line.key]: { kind:'quarantine', id:'Q', label:'Quarantined — does not match my catalog', conf:1 } };
setOverrides(newOverrides);
try { localStorage.setItem('astro.recon.overrides', JSON.stringify(newOverrides)); } catch {}
setActiveIdx(null);
};
const clearLearning = () => {
if (!confirm('Clear all learned matching rules? Auto-suggestions will reset.')) return;
setRules([]);
saveRules([]);
};
if (!stmtLoaded) {
return
Loading statements…
;
}
return (
{/* Breadcrumb */}
/RECONCILIATION QUEUE
{/* Hero */}
Reconciliation queue
Every income line gets matched to a Work or Recording. The matcher does this automatically where it can, and surfaces the rest here. Each manual match teaches the matcher for the next pass.