// financial/src/estate.jsx — the Estate section.
//
// Two jobs, in the order that actually matters.
//
// STRATEGY comes first even though the tab reads "Will" first, because the
// finding that changes outcomes is not in the will at all: most of this
// balance sheet passes by beneficiary designation or by survivorship, and a
// will written without checking those forms quietly contradicts them. The
// transfer map computes that from accounts the app already holds.
//
// WILL captures what a drafting attorney asks for in the first meeting, so
// the meeting is spent drafting rather than on discovery.
//
// Everything here reports or captures. It does not advise, and it does not
// state a legal threshold — see lib/estatePlan for why the exemption is an
// input carrying the date it was confirmed rather than a constant.
//
// Slices run in their own Babel scope; src/shared.jsx runs first and
// publishes window.FinanceShared.
const { useState, useContext, useMemo } = React;
const { DataContext, useToast, fmtCur, USER_PROFILE, calcAge } = window.FinanceShared;
const AGE_OF_MAJORITY = 18;
// The questions that need a specialist. Kept as data so the briefing export
// and the on-screen list cannot drift apart, and phrased as questions on
// purpose: the US/UK rules changed recently and an answer written here would
// be relied on.
const CROSS_BORDER_QUESTIONS = [
{ group: 'Citizenship and the marital deduction', weight: 'critical', items: [
'Are we both US citizens? If the surviving spouse is not, the unlimited marital deduction does not apply and transfers above the exemption are taxed at the first death unless a qualified domestic trust is used. Confirm before anything is drafted.',
'Does dual citizenship change the analysis, and for which of us?',
]},
{ group: 'UK inheritance tax reach', weight: 'critical', items: [
'On what basis would UK inheritance tax reach our worldwide estate, and does it apply to one of us or both? The UK moved from a domicile test to a residence-based test in 2025 — confirm the current rule and where we each fall under it.',
'What is the current UK threshold, and how does it compare with the US exemption?',
'How does the US/UK estate tax treaty allocate taxing rights and relieve double taxation?',
]},
{ group: 'If the children move to the UK', weight: 'critical', items: [
'How should a US trust be structured so it can support UK-resident beneficiaries without punitive treatment on distributions?',
'Should the trust be able to migrate its trustee or situs if the children actually relocate — build that in now, or accept it later?',
'Who would the trustee be in that scenario, and what reporting falls on a UK-resident guardian?',
'Should there be a parallel UK will covering UK-situs assets?',
]},
{ group: 'Inheriting from the UK', weight: 'normal', items: [
'If we inherit UK assets, what is owed and by whom? UK inheritance tax is generally settled by the estate before distribution — what lands on us as US recipients?',
'What reporting is triggered for a foreign bequest and foreign accounts, and what are the penalties for missing it?',
'Do inherited UK assets get a US cost-basis step-up?',
]},
{ group: 'The UK pension specifically', weight: 'normal', items: [
'Who inherits it, and does an expression-of-wish form override anything we write in a will?',
'Is it inside or outside our taxable estate on each side?',
]},
{ group: 'US mechanics', weight: 'normal', items: [
'Life insurance we own is included in our taxable estate. Is an irrevocable life insurance trust worth it at our numbers?',
'If a trust is named as beneficiary of retirement accounts, how must it be drafted to avoid accelerating the payout, and how does the ten-year rule apply to minor children?',
'Revocable living trust to avoid probate, or is Delaware probate light enough not to bother?',
'Confirm Delaware has no state estate or inheritance tax, and what the current federal exemption is.',
]},
];
// Roles a plan needs filled. `why` is shown next to each because the reason a
// role exists is the thing people actually need in order to choose someone.
const ROLES = [
{ key: 'guardianPerson', label: 'Guardian of the person', why: 'Raises the children. With no will, a court chooses.' },
{ key: 'guardianEstate', label: 'Guardian of the estate', why: 'Manages their money. Need not be the same person.' },
{ key: 'executor', label: 'Executor', why: 'Administers the estate through probate.' },
{ key: 'trustee', label: 'Trustee', why: 'May serve for decades, and here may deal with beneficiaries abroad.' },
{ key: 'poaFinancial', label: 'Financial power of attorney', why: 'Acts if you are alive but unable to. A will never covers this.' },
{ key: 'poaHealthcare', label: 'Healthcare proxy', why: 'Decides medical care, and holds your directive.' },
];
const ANCILLARY = [
{ key: 'financialPoa', label: 'Durable financial power of attorney' },
{ key: 'healthcarePoa', label: 'Healthcare power of attorney / advance directive' },
{ key: 'hipaa', label: 'HIPAA authorisation' },
{ key: 'letterOfIntent', label: 'Letter of intent to the guardian' },
{ key: 'digitalAssets', label: 'Digital asset access and password custody' },
{ key: 'burial', label: 'Funeral and burial wishes' },
];
function Field({ label, hint, children }) {
return (
{label}
{hint && {hint}}
{children}
);
}
function Estate() {
const { accounts, kidsPlan, estatePlan, estateDesignations, saveEstatePlan, saveEstateDesignation } = useContext(DataContext);
const { show, Toast } = useToast();
const [view, setView] = useState('strategy'); // 'strategy' | 'will' | 'briefing'
const [saving, setSaving] = useState(false);
const [editing, setEditing] = useState(null); // account id whose designation is open
// The stored plan is the source of truth until the moment you edit, and only
// then does a local draft take over. Copying the stored doc into state with
// an effect instead has two faults: the first render shows an empty form
// while the data is already in hand, and a later reload of the doc — a save
// from another tab, a provider refresh — silently overwrites edits in
// progress. A null draft means "nothing typed yet", which is a different
// state from "typed and identical".
const [draft, setDraft] = useState(null);
const cfg = draft || estatePlan || {};
const dirty = draft !== null;
const set = (patch) => setDraft(d => ({...(d || estatePlan || {}), ...patch}));
const setPerson = (role, slot, value) => {
const people = {...(cfg.people||{})};
people[role] = {...(people[role]||{}), [slot]: value};
set({people});
};
const save = async () => {
setSaving(true);
try { await saveEstatePlan(cfg); setDraft(null); show('Estate plan saved'); }
catch(e){ show(e.message,'error'); }
finally { setSaving(false); }
};
// Only children who are actually minors matter here — the flag exists
// because a minor cannot receive property, and an adult child can.
const minors = useMemo(()=>{
return ((kidsPlan && kidsPlan.kids) || [])
.filter(k => k && k.name && k.dob)
.map(k => ({ name: k.name, age: calcAge(k.dob) }))
.filter(k => k.age < AGE_OF_MAJORITY);
},[kidsPlan]);
const map = useMemo(
()=>EstatePlan.buildTransferMap(accounts, estateDesignations, { minors }),
[accounts, estateDesignations, minors]
);
const exposure = useMemo(()=>EstatePlan.probateExposure(map),[map]);
const gross = useMemo(()=>EstatePlan.grossEstate(map, cfg.policies||[]),[map, cfg.policies]);
// The date the youngest child stops depending on the cover. Term insurance
// that lapses before it is cover that isn't there when it is needed, and
// that date is derivable rather than something to ask for.
const dependentUntil = useMemo(()=>{
const kids = ((kidsPlan && kidsPlan.kids)||[]).filter(k=>k && k.dob);
if(!kids.length) return null;
const latest = kids.map(k=>{
const d = new Date(k.dob); d.setFullYear(d.getFullYear() + AGE_OF_MAJORITY); return d;
}).sort((a,b)=>b-a)[0];
return latest ? latest.toISOString().slice(0,10) : null;
},[kidsPlan]);
const policies = cfg.policies || [];
// Everyone a policy can be written on, from the real kid records rather
// than free text — a policy has to name a person the rest of the app knows,
// or the beneficiary and minor checks have nothing to match against.
const insurable = useMemo(()=>{
const kids = ((kidsPlan && kidsPlan.kids)||[])
.filter(k=>k && k.name)
.map(k=>({ value:`kid:${k.id||k.name}`, label:k.name, kind:'dependent' }));
return [
{ value:'you', label:'You', kind:'principal' },
{ value:'spouse', label:'Your wife', kind:'principal' },
...kids,
];
},[kidsPlan]);
// Cover in force counts the EARNERS only — see estatePlan.coverInForce.
const cover = useMemo(()=>EstatePlan.coverInForce(policies),[policies]);
const coverage = useMemo(()=>EstatePlan.lifeCoverageNeed({
...(cfg.coverageInputs||{}), coverInForce: cover.total,
}),[cfg.coverageInputs, cover.total]);
const policyAudit = useMemo(
()=>policies.map(p=>({ policy:p, flags: EstatePlan.policyFlags(p, {
minors, dependentUntil, principalShortfall: Math.max(0, coverage.gap),
}) })),
[policies, minors, dependentUntil, coverage.gap]
);
const setPolicy = (i, patch) => {
const next = policies.map((p,j)=>j===i?{...p,...patch}:p);
set({policies:next});
};
const headroom = useMemo(
()=>EstatePlan.exemptionHeadroom(gross.total, cfg.exemption, { today: new Date().toISOString().slice(0,10) }),
[gross, cfg.exemption]
);
const ready = useMemo(()=>EstatePlan.readiness(cfg, map),[cfg, map]);
const errorRows = map.filter(r => r.flags.some(f => f.severity === 'error'));
return (
{gross.ownedDeathBenefit>0 ? `incl. ${fmtCur(gross.ownedDeathBenefit)} life cover` : 'no policies captured'}
Transfer map
How each account actually moves. A will only reaches the rows marked Probate —
everything else is decided by a form held by the custodian or by how the title is worded, and never reads the will.
An account with no beneficiary recorded falls into probate by default, which is why it counts as at risk rather than outside it.
Usually the largest single sum a family ever receives, and the one asset bought once and never
looked at again. Who owns a policy decides whether its
death benefit sits inside the taxable estate — which is a different question from who receives it.
{policies.length === 0 && (
No policies recorded, so the gross estate above excludes life cover entirely and the coverage
check below has nothing to measure.
Built from obligations rather than a multiple of salary, because the multiple hides which
obligation is driving it — and the obligations are the part that changes as a mortgage
amortises and children age out.
{[['debts','Debts to clear','$'],['annualIncome','Annual income to replace','$'],
['incomeReplacementYears','Years of income',''],['childYearsRemaining','Total child-years to independence',''],
['costPerChildYear','Cost per child-year','$'],['education','Education','$'],
['finalExpenses','Final expenses','$'],['liquidAssets','Liquid assets already available','$']].map(([k,lbl,pre])=>(
set({coverageInputs:{...(cfg.coverageInputs||{}),[k]:Number(e.target.value)||0}})}/>
))}
{coverage.unknown
?
Fill in what applies and the shortfall appears here with its arithmetic.
:
{coverage.components.map((c,i)=>(
{c.label}{fmtCur(c.amount)}
))}
Cover needed{fmtCur(coverage.need)}
In force on you and your wife{fmtCur(cover.principal)}
{cover.dependent > 0 && (
On the children — not counted, it replaces no income{fmtCur(cover.dependent)}
Ask directly whether the firm has handled US/UK estates. These are questions rather than answers
because the rules changed recently — the UK moved to a residence-based test in 2025 — and a
summary held in an app is exactly the thing that goes stale and gets believed.
{CROSS_BORDER_QUESTIONS.map(g=>(
{g.group}{g.weight==='critical' && ' · critical'}
{g.items.map((q,i)=>
{q}
)}
))}
)}
{/* ── Will ─────────────────────────────────────────────────────────── */}
{view==='will' && (<>
Who does what
Name a backup for every role. A nomination with no alternate fails the moment the first choice
cannot serve, and that is when it matters.
With no trust the default is the entire share outright at {AGE_OF_MAJORITY}. Staging it is a
decision you make, not one the lawyer makes for you. A trustee can still pay for education,
health and housing before these ages.
{(cfg.distributionAges||[]).map((d,i)=>(
{ const a=[...cfg.distributionAges]; a[i]={...a[i],age:Number(e.target.value)}; set({distributionAges:a}); }}/>
years old →
{ const a=[...cfg.distributionAges]; a[i]={...a[i],pct:Number(e.target.value)}; set({distributionAges:a}); }}/>
% of their share
))}
{(cfg.distributionAges||[]).length>0 && (()=>{
const tot=(cfg.distributionAges||[]).reduce((s,d)=>s+(Number(d.pct)||0),0);
return {tot}% allocated{tot!==100?' — should total 100':''};
})()}