@uwmd/core 2.10.0 → 2.11.0

package/dist/validator.js

@@ -106,6 +106,9 @@ export function validateUWFile(parsed, thresholdOverrides) {
     checkSectionReadiness(parsed, issues, ledger);
     checkReturnsTaxBasis(parsed, issues);
     checkTaxBasis(parsed, issues);
+    checkLeaseClauses(parsed, issues);
+    checkHedgesAndEscrows(parsed, issues);
+    checkRenovationDraw(parsed, issues);
     checkLocale(parsed, issues);
     checkCurrencyIdentity(parsed, issues);
     checkAssetClassIdentifier(parsed, issues);
@@ -877,6 +880,603 @@ function checkTaxBasis(parsed, issues) {
         taxIssue(issues, 'TAX-08', 'dcf', `${base}.value_basis`, `TAX-08: terminal_tax.value_basis ${basis} must equal exit_value_gross ${gross} for a sale trigger, or state value_basis_differs_because`, basis);
     }
 }
+// ─── §4.3 Commercial lease clauses (RFC 0055) ────────────────────────────────
+//
+// RFC 0054 placed lease clauses on the lease record because they are attributes
+// of a lease, not of a period. These rules check stated terms: nothing escalates
+// a rent, exercises a break, applies a remedy or amortizes a balance.
+/** What a stated termination penalty is composed of. Closed. */
+export const TERMINATION_PENALTY_COMPONENTS = Object.freeze([
+    'unamortized_ti', 'unamortized_lc', 'free_rent', 'fee',
+]);
+export const CO_TENANCY_TRIGGERS = Object.freeze([
+    'named_tenant_departure', 'occupancy_threshold', 'both',
+]);
+export const CO_TENANCY_REMEDIES = Object.freeze([
+    'rent_reduction', 'alternate_rent', 'termination_right',
+]);
+const leaseNum = (v) => typeof v === 'number' && Number.isFinite(v);
+const isDate = (v) => typeof v === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(v) && parseISODate(v) !== null;
+function leaseIssue(issues, code, field, message, value) {
+    issues.push({
+        code, severity: 'error', section: 'rent_roll', field, message,
+        ...(value !== undefined ? { value } : {}),
+    });
+}
+function checkEscalationSchedule(t, issues, at) {
+    const steps = t['escalation_schedule'];
+    if (steps === undefined || steps === null)
+        return;
+    if (!Array.isArray(steps) || steps.length === 0) {
+        leaseIssue(issues, 'LSE-01', `${at}.escalation_schedule`, 'LSE-01: escalation_schedule must be a nonempty array when stated');
+        return;
+    }
+    // LSE-03: a flat lease does not carry a step schedule.
+    const type = t['escalation_type'];
+    if (type === undefined || type === null || type === 'none') {
+        leaseIssue(issues, 'LSE-03', `${at}.escalation_type`, 'LSE-03: a stated escalation_schedule requires an escalation_type other than "none"', type);
+    }
+    const dates = [];
+    for (const [i, raw] of steps.entries()) {
+        const p = `${at}.escalation_schedule[${i}]`;
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+            leaseIssue(issues, 'LSE-01', p, 'LSE-01: each escalation step must be an object');
+            return;
+        }
+        const step = raw;
+        if (!isDate(step['effective_date'])) {
+            leaseIssue(issues, 'LSE-01', `${p}.effective_date`, 'LSE-01: effective_date must be a real YYYY-MM-DD date', step['effective_date']);
+            return;
+        }
+        const rent = step['base_rent_annual'];
+        if (!leaseNum(rent) || rent < 0) {
+            leaseIssue(issues, 'LSE-01', `${p}.base_rent_annual`, 'LSE-01: base_rent_annual must be a finite nonnegative number', rent);
+            return;
+        }
+        dates.push(step['effective_date']);
+    }
+    for (let i = 1; i < dates.length; i++) {
+        if (dates[i - 1] >= dates[i]) {
+            leaseIssue(issues, 'LSE-01', `${at}.escalation_schedule[${i}].effective_date`, `LSE-01: escalation steps must strictly increase by date (${dates[i - 1]} then ${dates[i]})`, dates[i]);
+            return;
+        }
+    }
+    // LSE-02: steps live inside the lease term when the term is stated.
+    const start = t['lease_commencement'];
+    const end = t['lease_expiration'];
+    if (!isDate(start) || !isDate(end))
+        return;
+    for (const [i, d] of dates.entries()) {
+        if (d < start || d > end) {
+            leaseIssue(issues, 'LSE-02', `${at}.escalation_schedule[${i}].effective_date`, `LSE-02: escalation step ${d} lies outside the lease term ${start}..${end}`, d);
+            return;
+        }
+    }
+}
+function checkTerminationOption(t, issues, at) {
+    const raw = t['termination_option'];
+    if (raw === undefined || raw === null)
+        return;
+    const p = `${at}.termination_option`;
+    if (typeof raw !== 'object' || Array.isArray(raw)) {
+        leaseIssue(issues, 'LSE-04', p, 'LSE-04: termination_option must be an object when stated', raw);
+        return;
+    }
+    const opt = raw;
+    if (!isDate(opt['earliest_date'])) {
+        leaseIssue(issues, 'LSE-04', `${p}.earliest_date`, 'LSE-04: earliest_date must be a real YYYY-MM-DD date', opt['earliest_date']);
+        return;
+    }
+    const notice = opt['notice_months'];
+    if (!Number.isSafeInteger(notice) || notice < 0) {
+        leaseIssue(issues, 'LSE-04', `${p}.notice_months`, 'LSE-04: notice_months must be a nonnegative whole number of months', notice);
+    }
+    const penalty = opt['penalty'];
+    if (penalty !== undefined && penalty !== null && (!leaseNum(penalty) || penalty < 0)) {
+        leaseIssue(issues, 'LSE-04', `${p}.penalty`, 'LSE-04: a stated penalty must be a finite nonnegative amount; null means genuinely none', penalty);
+    }
+    const start = t['lease_commencement'];
+    const end = t['lease_expiration'];
+    if (isDate(start) && isDate(end)) {
+        const d = opt['earliest_date'];
+        if (d < start || d > end) {
+            leaseIssue(issues, 'LSE-04', `${p}.earliest_date`, `LSE-04: the break date ${d} lies outside the lease term ${start}..${end}`, d);
+        }
+    }
+    // LSE-05: what the penalty is composed of, from a closed list, without repeats.
+    const parts = opt['penalty_includes'];
+    if (parts === undefined || parts === null)
+        return;
+    if (!Array.isArray(parts) || parts.length === 0) {
+        leaseIssue(issues, 'LSE-05', `${p}.penalty_includes`, 'LSE-05: penalty_includes must be a nonempty array when stated');
+        return;
+    }
+    const seen = new Set();
+    for (const [i, part] of parts.entries()) {
+        if (typeof part !== 'string' || !TERMINATION_PENALTY_COMPONENTS.includes(part)) {
+            leaseIssue(issues, 'LSE-05', `${p}.penalty_includes[${i}]`, `LSE-05: penalty component must be one of ${TERMINATION_PENALTY_COMPONENTS.join(', ')}`, part);
+            return;
+        }
+        if (seen.has(part)) {
+            leaseIssue(issues, 'LSE-05', `${p}.penalty_includes[${i}]`, `LSE-05: penalty component ${part} is listed more than once`, part);
+            return;
+        }
+        seen.add(part);
+    }
+}
+function checkCoTenancy(t, issues, at) {
+    const raw = t['co_tenancy_details'];
+    const flag = t['co_tenancy_clause'];
+    const stated = raw !== undefined && raw !== null;
+    // LSE-06: the boolean and the body agree, or neither is stated. Same move
+    // TAX-04 made for sale_triggers_reassessment: a flag that asserts nothing
+    // until something has to agree with it.
+    if (stated && flag !== true) {
+        leaseIssue(issues, 'LSE-06', `${at}.co_tenancy_clause`, 'LSE-06: co_tenancy_details requires co_tenancy_clause: true', flag);
+        return;
+    }
+    if (!stated) {
+        if (flag === true) {
+            leaseIssue(issues, 'LSE-06', `${at}.co_tenancy_details`, 'LSE-06: co_tenancy_clause: true requires co_tenancy_details saying what triggers it and what the remedy is');
+        }
+        return;
+    }
+    const p = `${at}.co_tenancy_details`;
+    if (typeof raw !== 'object' || Array.isArray(raw)) {
+        leaseIssue(issues, 'LSE-06', p, 'LSE-06: co_tenancy_details must be an object when stated', raw);
+        return;
+    }
+    const d = raw;
+    const trigger = d['trigger'];
+    if (typeof trigger !== 'string' || !CO_TENANCY_TRIGGERS.includes(trigger)) {
+        leaseIssue(issues, 'LSE-07', `${p}.trigger`, `LSE-07: trigger must be one of ${CO_TENANCY_TRIGGERS.join(', ')}`, trigger);
+        return;
+    }
+    // LSE-07: the trigger carries what it needs.
+    if (trigger === 'named_tenant_departure' || trigger === 'both') {
+        const named = d['named_cotenants'];
+        if (!Array.isArray(named) || named.length === 0 || named.some(n => typeof n !== 'string' || n.length === 0)) {
+            leaseIssue(issues, 'LSE-07', `${p}.named_cotenants`, `LSE-07: trigger "${trigger}" requires a nonempty list of named co-tenants`, named);
+        }
+    }
+    if (trigger === 'occupancy_threshold' || trigger === 'both') {
+        const th = d['occupancy_threshold'];
+        if (!leaseNum(th) || th <= 0 || th >= 1) {
+            leaseIssue(issues, 'LSE-07', `${p}.occupancy_threshold`, `LSE-07: trigger "${trigger}" requires an occupancy_threshold fraction between 0 and 1, exclusive`, th);
+        }
+    }
+    const remedy = d['remedy'];
+    if (typeof remedy !== 'string' || !CO_TENANCY_REMEDIES.includes(remedy)) {
+        leaseIssue(issues, 'LSE-08', `${p}.remedy`, `LSE-08: remedy must be one of ${CO_TENANCY_REMEDIES.join(', ')}`, remedy);
+        return;
+    }
+    // LSE-08: a remedy that changes rent states by how much; a termination right does not.
+    const value = d['remedy_value'];
+    const hasValue = value !== undefined && value !== null;
+    if (remedy === 'termination_right') {
+        if (hasValue) {
+            leaseIssue(issues, 'LSE-08', `${p}.remedy_value`, 'LSE-08: a termination_right has no remedy_value; the remedy is the right itself', value);
+        }
+    }
+    else if (!hasValue) {
+        leaseIssue(issues, 'LSE-08', `${p}.remedy_value`, `LSE-08: remedy "${remedy}" requires a remedy_value`);
+    }
+    else if (remedy === 'rent_reduction' && (!leaseNum(value) || value <= 0 || value > 1)) {
+        leaseIssue(issues, 'LSE-08', `${p}.remedy_value`, 'LSE-08: a rent_reduction remedy_value is a fraction in (0, 1]', value);
+    }
+    else if (remedy === 'alternate_rent' && (!leaseNum(value) || value < 0)) {
+        leaseIssue(issues, 'LSE-08', `${p}.remedy_value`, 'LSE-08: an alternate_rent remedy_value is a nonnegative amount', value);
+    }
+    const cure = d['cure_period_months'];
+    if (cure !== undefined && cure !== null && (!Number.isSafeInteger(cure) || cure < 0)) {
+        leaseIssue(issues, 'LSE-07', `${p}.cure_period_months`, 'LSE-07: cure_period_months must be a nonnegative whole number of months', cure);
+    }
+}
+function checkLeasingCapital(t, issues, at) {
+    // LSE-09: state the balances. Amortization is periodic and RFC 0054 deferred it.
+    for (const [original, outstanding, label] of [
+        ['ti_allowance_original', 'ti_outstanding_balance', 'tenant improvement'],
+        ['lc_original', 'lc_outstanding_balance', 'leasing commission'],
+    ]) {
+        for (const key of [original, outstanding]) {
+            const v = t[key];
+            if (v === undefined || v === null)
+                continue;
+            if (!leaseNum(v) || v < 0) {
+                leaseIssue(issues, 'LSE-09', `${at}.${key}`, `LSE-09: ${key} must be a finite nonnegative amount`, v);
+            }
+        }
+        const o = t[original];
+        const b = t[outstanding];
+        if (leaseNum(o) && leaseNum(b) && o >= 0 && b >= 0 && b > o) {
+            leaseIssue(issues, 'LSE-09', `${at}.${outstanding}`, `LSE-09: the outstanding ${label} balance ${b} cannot exceed the original ${o}`, b);
+        }
+    }
+}
+function checkLeaseClauses(parsed, issues) {
+    const block = resolveCrossCheckSection(parsed, 'rent_roll').block;
+    if (!block)
+        return;
+    const tenants = deepGet(block.content, 'tenants');
+    if (!Array.isArray(tenants))
+        return;
+    for (const [i, raw] of tenants.entries()) {
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+            continue;
+        const t = raw;
+        const at = `tenants[${i}]`;
+        checkEscalationSchedule(t, issues, at);
+        checkTerminationOption(t, issues, at);
+        checkCoTenancy(t, issues, at);
+        checkLeasingCapital(t, issues, at);
+    }
+}
+// ─── §4.7 / §4.8 Rate hedges and escrows (RFC 0056) ──────────────────────────
+//
+// A cap's strike, notional and term are stated, never priced. Nothing values
+// the instrument, projects a strike crossing or rolls an escrow balance
+// forward — that needs a forward curve, which this contract does not fetch.
+// The one thing these rules insist on is that the author answer what happens
+// when the cap expires, and that a stated replacement is a funded line.
+/** The only instrument this contract types. Closed. */
+export const HEDGE_INSTRUMENTS = Object.freeze(['rate_cap']);
+/**
+ * Named, refused, and left for a mark-to-market contract. Both can be worth
+ * less than zero; a cap cannot. Typing them as caps would make the capital
+ * stack wrong in the one case that matters.
+ */
+export const RESERVED_HEDGE_INSTRUMENTS = Object.freeze([
+    'rate_swap', 'rate_collar',
+]);
+/** The `rate_index` vocabulary minus `fixed`, which a cap is not struck against. */
+export const HEDGE_INDEXES = Object.freeze([
+    'sofr', 'prime', 'treasury_5yr', 'treasury_10yr',
+]);
+/** What the author says happens in the month after the cap expires. No default. */
+export const HEDGE_EXPIRY_ASSUMPTIONS = Object.freeze([
+    'replace', 'unhedged', 'loan_matures_first',
+]);
+/** Closed, with a label-bearing `other` — the RFC 0052 shape. */
+export const ESCROW_NAMES = Object.freeze([
+    'tax', 'insurance', 'replacement_reserve', 'ti_lc',
+    'interest', 'operating', 'rate_cap_replacement', 'other',
+]);
+function hedgeIssue(issues, code, section, field, message, value) {
+    issues.push({ code, severity: 'error', section, field, message, ...(value !== undefined ? { value } : {}) });
+}
+/** The §4.7 hedge object: shape, the rate_type gate, and the legacy agreement. */
+function checkRateHedge(h, rateType, legacyCapPct, issues) {
+    const at = 'rate_hedge';
+    const inst = h['instrument'];
+    // HDG-02 before HDG-01: a reserved name earns its own message, not "unknown".
+    if (typeof inst === 'string' && RESERVED_HEDGE_INSTRUMENTS.includes(inst)) {
+        hedgeIssue(issues, 'HDG-02', 'debt_structure', `${at}.instrument`, `HDG-02: ${inst} is reserved for a later mark-to-market contract and is refused here — its value moves with the curve and can be negative, which a cap's cannot`, inst);
+    }
+    else if (typeof inst !== 'string' || !HEDGE_INSTRUMENTS.includes(inst)) {
+        hedgeIssue(issues, 'HDG-01', 'debt_structure', `${at}.instrument`, `HDG-01: instrument must be one of ${HEDGE_INSTRUMENTS.join(', ')}`, inst);
+    }
+    const notional = h['notional'];
+    if (!finiteNum(notional) || notional < 0) {
+        hedgeIssue(issues, 'HDG-01', 'debt_structure', `${at}.notional`, 'HDG-01: notional must be a finite nonnegative amount', notional);
+    }
+    // A fraction, not a percent — a strike of 3.5 is 350%, which is the mistake
+    // this bound exists to catch.
+    const strike = h['strike_rate'];
+    if (!finiteNum(strike) || strike <= 0 || strike >= 1) {
+        hedgeIssue(issues, 'HDG-01', 'debt_structure', `${at}.strike_rate`, 'HDG-01: strike_rate must be a fraction in (0, 1) — 0.035 is 3.5%', strike);
+    }
+    const index = h['index'];
+    if (typeof index !== 'string' || !HEDGE_INDEXES.includes(index)) {
+        hedgeIssue(issues, 'HDG-01', 'debt_structure', `${at}.index`, `HDG-01: index must be one of ${HEDGE_INDEXES.join(', ')}`, index);
+    }
+    const eff = h['effective_date'];
+    const exp = h['expiration_date'];
+    if (!isDate(eff)) {
+        hedgeIssue(issues, 'HDG-01', 'debt_structure', `${at}.effective_date`, 'HDG-01: effective_date must be a real YYYY-MM-DD date', eff);
+    }
+    if (!isDate(exp)) {
+        hedgeIssue(issues, 'HDG-01', 'debt_structure', `${at}.expiration_date`, 'HDG-01: expiration_date must be a real YYYY-MM-DD date', exp);
+    }
+    else if (isDate(eff) && exp <= eff) {
+        hedgeIssue(issues, 'HDG-01', 'debt_structure', `${at}.expiration_date`, `HDG-01: expiration_date ${exp} must be strictly after effective_date ${eff}`, exp);
+    }
+    const premium = h['premium'];
+    if (premium !== undefined && premium !== null && (!finiteNum(premium) || premium < 0)) {
+        hedgeIssue(issues, 'HDG-01', 'debt_structure', `${at}.premium`, 'HDG-01: premium must be a finite nonnegative amount, or null for genuinely none', premium);
+    }
+    // HDG-03: a fixed-rate loan does not carry a rate cap.
+    if (rateType !== 'floating' && rateType !== 'hybrid') {
+        hedgeIssue(issues, 'HDG-03', 'debt_structure', 'rate_type', `HDG-03: a stated rate_hedge requires rate_type "floating" or "hybrid" (found ${JSON.stringify(rateType)})`, rateType);
+    }
+    // HDG-04: the legacy scalar has to agree with the typed body.
+    if (finiteNum(legacyCapPct) && finiteNum(strike) && legacyCapPct !== strike) {
+        hedgeIssue(issues, 'HDG-04', 'debt_structure', 'rate_cap_pct', `HDG-04: rate_cap_pct ${legacyCapPct} disagrees with rate_hedge.strike_rate ${strike}`, legacyCapPct);
+    }
+    // HDG-06: no default. A cap's expiry is the fact the reader came for, and
+    // "unstated" is the answer that hides the cliff.
+    const after = h['post_expiration_assumption'];
+    if (typeof after !== 'string' || !HEDGE_EXPIRY_ASSUMPTIONS.includes(after)) {
+        hedgeIssue(issues, 'HDG-06', 'debt_structure', `${at}.post_expiration_assumption`, `HDG-06: post_expiration_assumption must be stated as one of ${HEDGE_EXPIRY_ASSUMPTIONS.join(', ')}`, after);
+    }
+}
+/** The §4.8 escrow array. Returns the set of names it managed to read. */
+function checkEscrows(escrows, uses, issues) {
+    const seen = new Set();
+    const at = 'uses.escrows';
+    if (!Array.isArray(escrows) || escrows.length === 0) {
+        hedgeIssue(issues, 'ESC-01', 'sources_uses', at, 'ESC-01: escrows must be a nonempty array when stated');
+        return seen;
+    }
+    const labels = new Set();
+    const upfrontByName = new Map();
+    for (const [i, raw] of escrows.entries()) {
+        const p = `${at}[${i}]`;
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+            hedgeIssue(issues, 'ESC-01', 'sources_uses', p, 'ESC-01: each escrow must be an object');
+            continue;
+        }
+        const e = raw;
+        const name = e['name'];
+        if (typeof name !== 'string' || !ESCROW_NAMES.includes(name)) {
+            hedgeIssue(issues, 'ESC-01', 'sources_uses', `${p}.name`, `ESC-01: escrow name must be one of ${ESCROW_NAMES.join(', ')}`, name);
+            continue;
+        }
+        const label = e['label'];
+        if (name === 'other') {
+            // ESC-02: `other` says nothing until the label says what it is.
+            if (typeof label !== 'string' || label.trim().length === 0) {
+                hedgeIssue(issues, 'ESC-02', 'sources_uses', `${p}.label`, 'ESC-02: an "other" escrow requires a nonempty label', label);
+            }
+            else if (labels.has(label.trim())) {
+                hedgeIssue(issues, 'ESC-02', 'sources_uses', `${p}.label`, `ESC-02: duplicate "other" escrow label ${JSON.stringify(label.trim())}`, label);
+            }
+            else {
+                labels.add(label.trim());
+            }
+        }
+        else {
+            if (label !== undefined && label !== null) {
+                hedgeIssue(issues, 'ESC-02', 'sources_uses', `${p}.label`, `ESC-02: only an "other" escrow carries a label; ${name} names itself`, label);
+            }
+            if (seen.has(name)) {
+                hedgeIssue(issues, 'ESC-02', 'sources_uses', `${p}.name`, `ESC-02: duplicate escrow name ${JSON.stringify(name)}`, name);
+            }
+        }
+        seen.add(name);
+        // ESC-01: an escrow that funds neither at close nor monthly is not one.
+        let stated = 0;
+        for (const key of ['upfront', 'monthly']) {
+            const v = e[key];
+            if (v === undefined || v === null)
+                continue;
+            if (!finiteNum(v) || v < 0) {
+                hedgeIssue(issues, 'ESC-01', 'sources_uses', `${p}.${key}`, `ESC-01: ${key} must be a finite nonnegative amount`, v);
+                continue;
+            }
+            stated++;
+            if (key === 'upfront' && !upfrontByName.has(name))
+                upfrontByName.set(name, v);
+        }
+        if (stated === 0) {
+            hedgeIssue(issues, 'ESC-01', 'sources_uses', p, 'ESC-01: an escrow must state at least one of upfront or monthly');
+        }
+    }
+    // ESC-03: the legacy scalars have to agree with the typed lines.
+    for (const [legacyKey, name] of [
+        ['interest_reserve', 'interest'],
+        ['operating_reserves', 'operating'],
+    ]) {
+        const legacy = uses[legacyKey];
+        const typed = upfrontByName.get(name);
+        if (finiteNum(legacy) && typed !== undefined && !sameMoney(legacy, typed)) {
+            hedgeIssue(issues, 'ESC-03', 'sources_uses', `uses.${legacyKey}`, `ESC-03: uses.${legacyKey} ${legacy} disagrees with the ${name} escrow's upfront ${typed}`, legacy);
+        }
+    }
+    return seen;
+}
+function checkHedgesAndEscrows(parsed, issues) {
+    const debt = resolveCrossCheckSection(parsed, 'debt_structure').block;
+    const su = resolveCrossCheckSection(parsed, 'sources_uses').block;
+    let assumption;
+    let hedgeStated = false;
+    if (debt) {
+        const h = deepGet(debt.content, 'rate_hedge');
+        if (h !== undefined && h !== null) {
+            if (typeof h !== 'object' || Array.isArray(h)) {
+                hedgeIssue(issues, 'HDG-01', 'debt_structure', 'rate_hedge', 'HDG-01: rate_hedge must be an object when stated', h);
+            }
+            else {
+                hedgeStated = true;
+                const rec = h;
+                assumption = rec['post_expiration_assumption'];
+                checkRateHedge(rec, deepGet(debt.content, 'rate_type'), deepGet(debt.content, 'rate_cap_pct'), issues);
+                // HDG-05: the premium is the same cash as the use that funds it.
+                const premium = rec['premium'];
+                const cost = su ? deepGet(su.content, 'uses.rate_cap_cost') : undefined;
+                if (finiteNum(premium) && finiteNum(cost) && !sameMoney(premium, cost)) {
+                    hedgeIssue(issues, 'HDG-05', 'debt_structure', 'rate_hedge.premium', `HDG-05: rate_hedge.premium ${premium} disagrees with sources_uses.uses.rate_cap_cost ${cost}`, premium);
+                }
+            }
+        }
+    }
+    if (!su)
+        return;
+    const uses = deepGet(su.content, 'uses');
+    if (uses === null || typeof uses !== 'object' || Array.isArray(uses))
+        return;
+    const u = uses;
+    const escrows = u['escrows'];
+    const names = escrows === undefined || escrows === null
+        ? new Set()
+        : checkEscrows(escrows, u, issues);
+    // ESC-04: the rule that turns "this cap expires in year three" from a note
+    // into a funded line. Both directions, so neither side can drift alone.
+    const wantsReplacement = hedgeStated && assumption === 'replace';
+    const hasReplacement = names.has('rate_cap_replacement');
+    if (wantsReplacement && !hasReplacement) {
+        hedgeIssue(issues, 'ESC-04', 'sources_uses', 'uses.escrows', 'ESC-04: rate_hedge.post_expiration_assumption "replace" requires a rate_cap_replacement escrow');
+    }
+    else if (hasReplacement && !wantsReplacement) {
+        hedgeIssue(issues, 'ESC-04', 'sources_uses', 'uses.escrows', `ESC-04: a rate_cap_replacement escrow requires rate_hedge.post_expiration_assumption "replace" (found ${JSON.stringify(assumption)})`, assumption);
+    }
+}
+// ─── §4.8 Renovation draw and expense-targeted capex (RFC 0057) ──────────────
+//
+// A contingency is the number a construction lender watches, and two deals
+// stating the same one are indistinguishable when one has drawn none of it and
+// the other has drawn all of it. These rules read the draw the author stated.
+//
+// Nothing here applies a saving. `annual_savings` is never subtracted from an
+// expense line, from EGI or from NOI — `in_noi_model` records whether the author
+// already did, and CAPX-07 makes them say so, because a stated saving with no
+// such flag is how a document gets double-counted.
+/** Where the payback arithmetic is compared. Years, not money. */
+const PAYBACK_DP = 4;
+function capxIssue(issues, code, field, message, value) {
+    issues.push({
+        code, severity: 'error', section: 'sources_uses', field, message,
+        ...(value !== undefined ? { value } : {}),
+    });
+}
+/**
+ * One `expense_targeted` entry. `expenseKeys` is null when `noi_model` is absent
+ * or unreadable, in which case CAPX-06 checks the shape but not the target.
+ */
+function checkExpenseTargeted(e, expenseKeys, issues, at) {
+    const label = e['label'];
+    if (typeof label !== 'string' || label.trim().length === 0) {
+        capxIssue(issues, 'CAPX-06', `${at}.label`, 'CAPX-06: an expense-targeted capex entry requires a nonempty label', label);
+    }
+    for (const key of ['amount', 'annual_savings']) {
+        const v = e[key];
+        if (!finiteNum(v) || v < 0) {
+            capxIssue(issues, 'CAPX-06', `${at}.${key}`, `CAPX-06: ${key} must be a finite nonnegative amount`, v);
+        }
+    }
+    const begin = e['savings_begin'];
+    if (typeof begin !== 'string' || taxPeriodKind(begin) === null) {
+        capxIssue(issues, 'CAPX-06', `${at}.savings_begin`, 'CAPX-06: savings_begin must be an RFC 0041 period selector (Y1+, YYYY-Qn, YYYY-MM or YYYY-MM-DD)', begin);
+    }
+    // The target is checked against the keys actually present, not a hardcoded
+    // list, so a module adding a class-specific expense line keeps working.
+    const targets = e['targets'];
+    if (typeof targets !== 'string' || targets.trim().length === 0) {
+        capxIssue(issues, 'CAPX-06', `${at}.targets`, 'CAPX-06: targets must name the noi_model.expenses key this project reduces', targets);
+    }
+    else if (expenseKeys !== null && !expenseKeys.has(targets)) {
+        capxIssue(issues, 'CAPX-06', `${at}.targets`, `CAPX-06: targets ${JSON.stringify(targets)} names no key under noi_model.expenses`, targets);
+    }
+    // CAPX-07: the disclosure that keeps a reader from applying the saving twice.
+    if (typeof e['in_noi_model'] !== 'boolean') {
+        capxIssue(issues, 'CAPX-07', `${at}.in_noi_model`, 'CAPX-07: in_noi_model must state whether this saving is already inside noi_model', e['in_noi_model']);
+    }
+    const payback = e['simple_payback_years'];
+    if (payback === undefined || payback === null)
+        return;
+    const amount = e['amount'];
+    const savings = e['annual_savings'];
+    if (!finiteNum(payback) || payback < 0) {
+        capxIssue(issues, 'CAPX-08', `${at}.simple_payback_years`, 'CAPX-08: simple_payback_years must be a finite nonnegative number', payback);
+        return;
+    }
+    if (!finiteNum(amount) || !finiteNum(savings))
+        return;
+    // A project with no stated saving has no payback period; a number there
+    // would be a fiction, so state nothing rather than Infinity.
+    if (savings === 0) {
+        capxIssue(issues, 'CAPX-08', `${at}.simple_payback_years`, 'CAPX-08: simple_payback_years cannot be stated against zero annual_savings', payback);
+        return;
+    }
+    const expected = quantizeAtDecimals(amount / savings, PAYBACK_DP);
+    if (quantizeAtDecimals(payback, PAYBACK_DP) !== expected) {
+        capxIssue(issues, 'CAPX-08', `${at}.simple_payback_years`, `CAPX-08: simple_payback_years ${payback} must equal amount / annual_savings (${expected})`, payback);
+    }
+}
+function checkRenovationDraw(parsed, issues) {
+    const su = resolveCrossCheckSection(parsed, 'sources_uses').block;
+    if (!su)
+        return;
+    const r = deepGet(su.content, 'uses.renovation');
+    if (r === undefined || r === null)
+        return;
+    const at = 'uses.renovation';
+    if (typeof r !== 'object' || Array.isArray(r)) {
+        capxIssue(issues, 'CAPX-01', at, 'CAPX-01: renovation must be an object when stated', r);
+        return;
+    }
+    const ren = r;
+    for (const key of ['budget', 'contingency', 'contingency_used', 'drawn_to_date']) {
+        const v = ren[key];
+        if (!finiteNum(v) || v < 0) {
+            capxIssue(issues, 'CAPX-01', `${at}.${key}`, `CAPX-01: ${key} must be a finite nonnegative amount`, v);
+        }
+    }
+    if (!isDate(ren['as_of_date'])) {
+        capxIssue(issues, 'CAPX-01', `${at}.as_of_date`, 'CAPX-01: as_of_date must be a real YYYY-MM-DD date', ren['as_of_date']);
+    }
+    // The relational rules below only compare figures CAPX-01 accepted: a bound
+    // computed from a budget we just refused as negative is noise, not a finding.
+    const amt = (v) => finiteNum(v) && v >= 0;
+    const budget = ren['budget'];
+    const contingency = ren['contingency'];
+    const used = ren['contingency_used'];
+    const drawn = ren['drawn_to_date'];
+    // CAPX-02: a contingency drawn past its size is an overrun, and calling it a
+    // contingency is what hides that.
+    if (amt(contingency) && amt(used) && used > contingency) {
+        capxIssue(issues, 'CAPX-02', `${at}.contingency_used`, `CAPX-02: contingency_used ${used} exceeds the contingency ${contingency} — that is an overrun, not a contingency`, used);
+    }
+    if (amt(drawn)) {
+        if (amt(budget) && amt(contingency) && drawn > budget + contingency) {
+            capxIssue(issues, 'CAPX-03', `${at}.drawn_to_date`, `CAPX-03: drawn_to_date ${drawn} exceeds budget plus contingency (${budget + contingency})`, drawn);
+        }
+        if (amt(used) && drawn < used) {
+            capxIssue(issues, 'CAPX-03', `${at}.drawn_to_date`, `CAPX-03: drawn_to_date ${drawn} is below contingency_used ${used}; the contingency draw is part of the total`, drawn);
+        }
+    }
+    // CAPX-04: stated and verified, the RFC 0052 net_sale_proceeds posture — the
+    // figure a lender quotes should be checkable, not recomputed by every reader.
+    const remaining = ren['contingency_remaining'];
+    if (remaining !== undefined && remaining !== null) {
+        if (!finiteNum(remaining)) {
+            capxIssue(issues, 'CAPX-04', `${at}.contingency_remaining`, 'CAPX-04: contingency_remaining must be a finite number when stated', remaining);
+        }
+        else if (amt(contingency) && amt(used) && !sameMoney(remaining, contingency - used)) {
+            capxIssue(issues, 'CAPX-04', `${at}.contingency_remaining`, `CAPX-04: contingency_remaining ${remaining} must equal contingency less contingency_used (${contingency - used})`, remaining);
+        }
+    }
+    // CAPX-05: the legacy scalars have to agree with the typed body.
+    for (const [legacyKey, typedKey] of [
+        ['renovation_budget', 'budget'],
+        ['renovation_contingency', 'contingency'],
+    ]) {
+        const legacy = deepGet(su.content, `uses.${legacyKey}`);
+        const typed = ren[typedKey];
+        if (finiteNum(legacy) && amt(typed) && !sameMoney(legacy, typed)) {
+            capxIssue(issues, 'CAPX-05', `uses.${legacyKey}`, `CAPX-05: uses.${legacyKey} ${legacy} disagrees with renovation.${typedKey} ${typed}`, legacy);
+        }
+    }
+    const targeted = ren['expense_targeted'];
+    if (targeted === undefined || targeted === null)
+        return;
+    if (!Array.isArray(targeted) || targeted.length === 0) {
+        capxIssue(issues, 'CAPX-06', `${at}.expense_targeted`, 'CAPX-06: expense_targeted must be a nonempty array when stated');
+        return;
+    }
+    const noi = resolveCrossCheckSection(parsed, 'noi_model').block;
+    const expenses = noi ? deepGet(noi.content, 'expenses') : undefined;
+    const expenseKeys = expenses !== null && typeof expenses === 'object' && !Array.isArray(expenses)
+        ? new Set(Object.keys(expenses))
+        : null;
+    for (const [i, raw] of targeted.entries()) {
+        const p = `${at}.expense_targeted[${i}]`;
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+            capxIssue(issues, 'CAPX-06', p, 'CAPX-06: each expense_targeted entry must be an object');
+            continue;
+        }
+        checkExpenseTargeted(raw, expenseKeys, issues, p);
+    }
+}
 // ─── §4.23 Mixed-use components (RFC 0019) ───────────────────────────────────
 // The eight income classes admissible as a mixed-use component. `land` is
 // excluded (its NOI model nets negative) and `mixed_use` cannot nest in itself.