{label}

); } // ─── 1. OVERVIEW ────────────────────────────────────────────────────────────── function ChainOverview({ data }) { const esi = window.__esi; const k = data.chainKpis; const tenRecent = data.chainOfCustody.slice(0, 6); // transfer method distribution const methodCounts = {}; data.chainOfCustody.forEach(c => { methodCounts[c.transferMethod] = (methodCounts[c.transferMethod] || 0) + 1; }); const methodBars = Object.entries(methodCounts).sort((a, b) => b[1] - a[1]).slice(0, 5); const maxMethod = Math.max(...methodBars.map(m => m[1])); // volume-by-actor-role const roleVol = {}; data.chainOfCustody.forEach(c => { roleVol[c.actorRole] = (roleVol[c.actorRole] || 0) + (c.volumeGB || 0); }); const roleBars = Object.entries(roleVol).sort((a, b) => b[1] - a[1]); const maxRole = Math.max(...roleBars.map(r => r[1])); return (

{/* Hero compliance banner */}

◆ Court-admissible chain of custody — ISO 27050-2 · FRE 901/902 compliant

Every transfer end-to-end SHA-256 hashed and witnessed. Tamper-evident seals applied at every node. Zero integrity failures year-to-date across {k.totalEvents} events and {esi.bytes(k.volumeTrackedGB)} tracked volume.

{/* KPI strip — 8 metrics */}

Events (total){k.totalEvents}+{k.eventsMTD} MTD

Hash verified{k.hashVerifiedPct.toFixed(1)}%{k.hashAlgorithm}

Integrity failures{k.integrityFailures}YTD

Volume tracked{esi.bytes(k.volumeTrackedGB)}

Seals active{k.sealsActive}{k.sealsBroken} broken

Transfers in flight{k.transfersInFlight}{k.transfersCompleted} complete

Attestations{k.attestationsSigned}{k.attestationsPending} pending

Court exports{k.exportsPrepared}{k.exportsCourtReady} court-ready

{/* Compliance posture strip */}

Compliance posture

{[ { label: 'Daubert', value: k.daubert, color: esi.emerald }, { label: 'FRE 901', value: k.fre901, color: esi.emerald }, { label: 'FRE 902(14)', value: k.fre902, color: esi.emerald }, { label: 'ISO 27050-2', value: 'Compliant', color: esi.emerald }, { label: 'Audit findings',value: `${k.auditFindings} open`, color: k.auditFindings === 0 ? esi.emerald : esi.amber }, ].map(p => (

{p.label}

{p.value}

))}

Last audit {k.lastAuditDate} · next audit {k.nextAuditDate} · auditor BSI

{/* Two-column: method distribution + actor role volume */}

Transfer method distribution

{methodBars.map(([method, count]) => (

{method} {count}

))}

Volume handled by actor role

{roleBars.map(([role, vol]) => (

{role} {esi.bytes(vol)}

))}

{/* Recent events + compliance sidecar */}

Recent chain events {tenRecent.length} of {data.chainOfCustody.length}

{tenRecent.map((c, i) => (

{c.id}

{c.from} → {c.to}

{c.custodian} · {c.actor}

{esi.bytes(c.volumeGB)} {c.hashVerified ? ok verified : ! pending}

))}

What you can prove in court

Every data transfer in this matter is:

{[ 'End-to-end SHA-256 hashed', 'Witnessed by ≥ 1 attested actor', 'Sealed (physical or cryptographic)', 'Logged with immutable audit entry', 'Declared under FRE 902(14)', ].map(item => (

{item}

))}

Daubert-ready: methods peer-reviewed, published, and with known error rates.

); } // ─── 2. LEDGER ──────────────────────────────────────────────────────────────── function ChainLedger({ data }) { const esi = window.__esi; const [q, setQ] = useChainState(''); const [fromFilter, setFromFilter] = useChainState('All'); const [verifiedOnly, setVerifiedOnly] = useChainState(false); const [selected, setSelected] = useChainState(null); const fromTypes = useChainMemo(() => ['All', ...new Set(data.chainOfCustody.map(c => c.fromType))], [data]); const rows = useChainMemo(() => data.chainOfCustody.filter(c => { const blob = `${c.id} ${c.from} ${c.to} ${c.custodian} ${c.actor} ${c.note}`.toLowerCase(); if (q && !blob.includes(q.toLowerCase())) return false; if (fromFilter !== 'All' && c.fromType !== fromFilter) return false; if (verifiedOnly && !c.hashVerified) return false; return true; }), [data, q, fromFilter, verifiedOnly]); const totalVol = rows.reduce((s, r) => s + (r.volumeGB || 0), 0); return (

Events shown{rows.length}of {data.chainOfCustody.length}

Volume (filtered){esi.bytes(totalVol)}

Hash verified{rows.filter(r => r.hashVerified).length}

Distinct actors{new Set(rows.map(r => r.actor)).size}

Custody ledger

setQ(e.target.value)} style={{ padding: '4px 10px', fontSize: '11px', border: `1px solid ${Tchain.color.border.light}`, borderRadius: '5px', background: Tchain.color.bg.card, color: Tchain.color.text.primary, width: '260px' }} /> setVerifiedOnly(e.target.checked)} /> verified only

{rows.map(c => { const isSel = selected === c.id; return ( setSelected(isSel ? null : c.id)} style={{ cursor: 'pointer', background: isSel ? esi.violetBg : 'transparent' }}> {isSel && ( )} ); })}

Chain ID	Date / time	From	To	Custodian / Scope	Volume	Actor / Role	Method	Seal	Hash
{c.id}	{c.date}	{c.from} {c.fromType}	{c.to} {c.toType}	{c.custodian}	{esi.bytes(c.volumeGB)}	{c.actor} {c.actorRole}	{c.transferMethod}	{c.sealId}	{c.hashVerified ? ok {c.hashAlgo} : pending}	{isSel ? '− collapse' : '+ expand'}
Hash integrity Algorithm: {c.hashAlgo} Pre: Post: Match: {c.hashVerified ? VERIFIED : PENDING} Witnesses & signatures Actor: {c.actor} ({c.actorRole}) Witness: {c.witness} Signature: {c.sig} Seal: {c.sealId} Links Source: {c.sourceId} Collection: {c.linkedCollection} Doc count: {c.docCount ? c.docCount.toLocaleString() : '—'} Volume: {esi.bytes(c.volumeGB)} Note: {c.note}

); } // ─── 3. INTEGRITY ───────────────────────────────────────────────────────────── function ChainIntegrity({ data }) { const esi = window.__esi; const rows = data.chainIntegrity; const matched = rows.filter(r => r.match).length; const totalBytes = rows.reduce((s, r) => s + r.bytesHashed, 0); return (

◆ Hash integrity — {matched} of {rows.length} verified

SHA-256 computed at source and re-verified at destination for every transfer. {(totalBytes / 1_073_741_824).toFixed(1)} GB hashed across this matter with zero mismatches.

Records{rows.length}

Matched{matched}

Mismatches{rows.length - matched}

Bytes hashed{(totalBytes / 1_073_741_824).toFixed(1)} GB

Hash registry — {rows.length} records

{rows.map(r => ( ))}

Record	Chain	Date	Algo	Pre-transfer hash	Post-transfer hash	Match	Bytes	Duration	Verifier
{r.id}	{r.chainId}	{r.date}	{r.algorithm}			{r.match ? ok MATCH : x MISMATCH}	{(r.bytesHashed / 1_073_741_824).toFixed(2)} GB	{r.duration}	{r.verifier}

); } // ─── 4. TRANSFERS ───────────────────────────────────────────────────────────── function ChainTransfers({ data }) { const esi = window.__esi; const inFlight = data.chainTransfers; return (

◆ Active transfers — {inFlight.length} in flight

Every transfer — physical or logical — is tracked with tamper-evident controls and streaming SHA-256 hash. Couriers are bonded; APIs are TLS 1.3.

In flight{inFlight.length}

Completed YTD{data.chainKpis.transfersCompleted}

Bonded couriers{data.chainCouriers.filter(c => c.type === 'Bonded courier' || c.type.includes('forensicist') || c.type === 'Forensic Collector').length}

Failed transfers0YTD

{/* Active transfers — detailed cards */}

{inFlight.map(t => (

{t.id} → chain {t.chainId} {t.status}

{t.from} → {t.to}

Method: {t.method} · Courier: {t.courier}

Progress {t.progressPct}%

Custodian

{t.custodian}

Volume (est.)

{esi.bytes(t.etaVolumeGB)}

Started

{t.started}

ETA

{t.eta}

Integrity: {t.integrity} — {t.note}

))}

{/* Couriers directory */}

Courier directory — {data.chainCouriers.length}

{data.chainCouriers.map(c => ( ))}

ID	Name	Organization	Type	License	Insured	Active	YTD	Note
{c.id}	{c.name}	{c.org}	{c.type}	{c.license}	{c.insured}	0 ? esi.cyan : Tchain.color.text.tertiary, fontWeight: 700 }}>{c.activeTransfers}	{c.completedYTD}	{c.note}

); } // ─── 5. SEALS ───────────────────────────────────────────────────────────────── function ChainSeals({ data }) { const esi = window.__esi; const seals = data.chainSeals; const intact = seals.filter(s => s.status === 'Intact').length; const broken = seals.filter(s => s.status.includes('Opened') || s.status === 'Broken').length; const statusStyle = (s) => { if (s === 'Intact') return { bg: esi.emeraldBg, color: esi.emerald }; if (s === 'Broken') return { bg: esi.crimsonBg, color: esi.crimson }; return { bg: esi.amberBg, color: esi.amber }; }; return (

◆ Evidence seals & containers — tamper-evident controls

Physical seals (tamper-evident, ultrasonic) and cryptographic seals (PGP, TLS, signed ZIP) applied to every container. Broken seals trigger re-hash + witness attestation.

Total seals{seals.length}

Intact{intact}

Broken / re-sealed{broken}all witnessed

Physical{seals.filter(s => s.type === 'Physical').length}

Logical{seals.filter(s => s.type === 'Logical').length}

Seal registry — {seals.length}

{seals.map(s => { const ss = statusStyle(s.status); return ( ); })}

Seal	Type	Material / Mechanism	Container	Chain	Sealed on	Sealed by	Location	Status	Notes
{s.id}	{s.type}	{s.material}	{s.container}	{s.chainId}	{s.sealedOn}	{s.sealedBy}	{s.location}	{s.status}	{s.note}

); } // ─── 6. ATTESTATIONS ────────────────────────────────────────────────────────── function ChainAttestations({ data }) { const esi = window.__esi; const [statusFilter, setStatusFilter] = useChainState('All'); const att = data.chainAttestations; const statuses = ['All', ...new Set(att.map(a => a.status))]; const rows = att.filter(a => statusFilter === 'All' || a.status === statusFilter); const signed = att.filter(a => a.status === 'Signed').length; const pending = att.filter(a => a.status === 'Pending').length; return (

◆ Custodian attestations — sworn declarations

Notarized affidavits from custodians, collectors, and records custodians. FRE 902(14) self-authenticating declarations attached to every production bundle.

Total attestations{att.length}

Signed{signed}

Pending{pending}

Types in use{new Set(att.map(a => a.type)).size}

Attestation registry — {rows.length} of {att.length}

{rows.map(a => ( ))}

ID	Custodian / Affiant	Role	Type	Status	Signed on	Notary	Exhibit	Linked chains	Note
{a.id}	{a.custodian}	{a.role}	{a.type}	{a.status === 'Signed' ? ok signed : pending}	{a.signedOn \|\| '—'}	{a.notary \|\| '—'}	{a.exhibit}	{a.relatedChains.join(', ') \|\| '—'}	{a.note}

); } // ─── 7. EXPORTS ─────────────────────────────────────────────────────────────── function ChainExports({ data }) { const esi = window.__esi; const exp = data.chainExports; const delivered = exp.filter(e => e.status === 'Delivered' || e.status === 'Filed').length; const totalEvents = exp.reduce((s, e) => s + e.events, 0); const statusStyle = (s) => { const m = { 'Delivered': { bg: esi.emeraldBg, color: esi.emerald }, 'Filed': { bg: esi.emeraldBg, color: esi.emerald }, 'In QC': { bg: esi.cyanBg, color: esi.cyan }, 'Drafting': { bg: esi.amberBg, color: esi.amber }, }; return m[s] || { bg: Tchain.color.bg.secondary, color: Tchain.color.text.secondary }; }; return (

◆ Court-admissible export bundles — FRE 901/902 + ISO 27050-2

Each export bundle includes the chain manifest, SHA-256 hash table, custodian declarations (FRE 902(14)), seal registry, and PGP-signed cover page. Bundles are court-admissible out of the box.

Exports prepared{exp.length}

Delivered / filed{delivered}

Events packaged{totalEvents}

Admissibility flags100%FRE 901/902 · ISO

Export bundles — {exp.length}

{exp.map(e => { const ss = statusStyle(e.status); return ( ); })}

ID	Title	Prepared on	Prepared by	Recipient	Format	Events	Attest.	Seals	Admissibility	Status	Tracking
{e.id}	{e.title}	{e.preparedOn}	{e.preparedBy}	{e.recipient}	{e.format}	{e.events}	{e.attestations}	{e.seals}	{e.fre901 && FRE 901} {e.fre902 && FRE 902} {e.iso27050 && ISO 27050}	{e.status}	{e.trackingNum \|\| '—'}

); } // ─── 8. COMPLIANCE ──────────────────────────────────────────────────────────── function ChainCompliance({ data }) { const esi = window.__esi; const std = data.chainStandards; const avgCoverage = Math.round(std.reduce((s, r) => s + r.coverage, 0) / std.length); const totalFindings = std.reduce((s, r) => s + r.findings, 0); return (

◆ Compliance posture — {avgCoverage}% average coverage

{std.length} standards tracked across federal rules, ISO, NIST, and professional-conduct authorities. {totalFindings} open finding(s); last external audit {data.chainKpis.lastAuditDate} by BSI.

Standards tracked{std.length}

Avg coverage{avgCoverage}%

Open findings{totalFindings}

Last / next audit{data.chainKpis.lastAuditDate}next {data.chainKpis.nextAuditDate}

Standards & rule coverage

{std.map(s => ( ))}

Code	Title	Applied to	Coverage	Last audit	Auditor	Findings	Note
{s.code}	{s.title}	{s.applied.map(a => {a})}	= 100 ? esi.emerald : s.coverage >= 90 ? esi.cyan : esi.amber }} /> = 100 ? esi.emerald : esi.cyan} weight={700}>{s.coverage}%	{s.lastAudit}	{s.auditor}	{s.findings === 0 ? 0 open : {s.findings} open}	{s.note}

); } // ─── 9. AUDIT TRAIL ─────────────────────────────────────────────────────────── function ChainAudit({ data }) { const esi = window.__esi; const [actionFilter, setActionFilter] = useChainState('All'); const audit = data.chainAudit; const actions = ['All', ...new Set(audit.map(a => a.action))]; const rows = audit.filter(a => actionFilter === 'All' || a.action === actionFilter); const sevStyle = (s) => s === 'error' ? { bg: esi.crimsonBg, color: esi.crimson } : s === 'warn' ? { bg: esi.amberBg, color: esi.amber } : { bg: esi.emeraldBg, color: esi.emerald }; const actionColor = (a) => { if (a.includes('BREAK') || a.includes('FAIL')) return esi.crimson; if (a.includes('SEAL') || a.includes('VERIFY')) return esi.cobalt; if (a.includes('TRANSFER') || a.includes('INGEST') || a.includes('EXPORT')) return esi.cyan; if (a.includes('AUDIT')) return esi.violet; return esi.slate; }; return (

◆ Tamper-evident audit trail — HMAC-SHA256 signed

Every chain event generates an immutable audit record. Records are HMAC-signed, append-only, and externally witnessed by a compliance daemon. Log truncation or rewrite is detectable and alarmed.

Audit records{audit.length}

Signature verified100%HMAC-SHA256

Warnings{audit.filter(a => a.severity === 'warn').length}

Errors{audit.filter(a => a.severity === 'error').length}

Audit log — {rows.length} of {audit.length}

{rows.map(r => { const ss = sevStyle(r.severity); const ac = actionColor(r.action); return ( ); })}

Record	Timestamp	Actor	Action	Target	Before	After	IP / Location	Signature	Severity
{r.id}	{r.ts}	{r.actor}	{r.action}	{r.target}	{r.before}	{r.after}	{r.ip}	{r.sig}	{r.severity}

); } // ─── ROOT — ESIChainOfCustody ───────────────────────────────────────────────── function ESIChainOfCustody({ data }) { const esi = window.__esi; const [view, setView] = useChainState('overview'); const renderView = () => { switch (view) { case 'overview': return ; case 'ledger': return ; case 'integrity': return ; case 'transfers': return ; case 'seals': return ; case 'attestations': return ; case 'exports': return ; case 'compliance': return ; case 'audit': return ; default: return ; } }; return (

{renderView()}

); } window.ESIChainOfCustody = ESIChainOfCustody;