@uwmd/core 2.9.0 → 2.11.0

package/dist/validator.js

@@ -2,13 +2,13 @@
 // Spec: UW_FORMAT_SPEC_v1.md Part V
 import { DEFAULT_THRESHOLDS, SOURCE_TAGS } from './types.js';
 import { getSection, getSectionVariant, deepGet } from './parser.js';
-import { BUILTIN_REMEDIATIONS, BUILTIN_INCOMPLETE_DATA_POLICIES, lookupIncompleteDataPolicy, getSizeIntensive, DEAL_UNDERWRITING_PROFILE, parseActorSource, isSupportedLocale, STAGE_REQUIREMENTS, requiredSectionsFor, CROSS_CHECK_RULE_IDS, RETURN_TAX_BASES, DEFAULT_RETURN_TAX_BASIS, } from './protocol.js';
+import { BUILTIN_REMEDIATIONS, BUILTIN_INCOMPLETE_DATA_POLICIES, lookupIncompleteDataPolicy, getSizeIntensive, DEAL_UNDERWRITING_PROFILE, parseActorSource, isSupportedLocale, isCurrencyCode, STAGE_REQUIREMENTS, requiredSectionsFor, CROSS_CHECK_RULE_IDS, RETURN_TAX_BASES, DEFAULT_RETURN_TAX_BASIS, } from './protocol.js';
 import { EXTERNAL_ANNOTATION_KEY } from './composition.js';
 import { UW_LITE_SOURCE_EXTENSION } from './lite-bridge.js';
 import { readGapsContent } from './gaps.js';
 import { LEASE_UP_STABILIZED_TOLERANCE } from './lease-up.js';
 import { checkLeaseUpContent } from './lease-up-structure.js';
-import { CASH_FLOW_KINDS } from './cash-flow-series.js';
+import { CASH_FLOW_KINDS, CASH_FLOW_VERIFY_DECIMALS, quantizeAtDecimals } from './cash-flow-series.js';
 import { isDayCountConvention, parseISODate } from './calc/day-count.js';
 import { parseAssetClass, declaredModuleDependencies } from './asset-class.js';
 import { isV2File } from './meta-shape.js';
@@ -105,7 +105,12 @@ export function validateUWFile(parsed, thresholdOverrides) {
     checkSizeIntensive(parsed, issues, ledger);
     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);
     checkMetaIntegrity(parsed, issues);
     checkMetaShape(parsed, issues);
@@ -636,6 +641,842 @@ function checkReturnsTaxBasis(parsed, issues) {
         value: v,
     });
 }
+// ─── §4.5 / §4.9 Tax abatements and reassessment basis (RFC 0053) ────────────
+//
+// Every rule here checks a figure the author stated. Nothing is derived, no
+// jurisdiction rules are inferred, and the exit-value/terminal-tax circularity
+// is left to the author — the calc engine has no iteration and this adds none.
+// Quantize with the §VIII.5 helper the cash-flow verifier exports rather than
+// keeping a second copy of the rounding rule.
+/** What caused the reassessment; `none` means none applies. */
+export const REASSESSMENT_TRIGGERS = Object.freeze([
+    'sale', 'construction_completion', 'statutory_cycle', 'none',
+]);
+export const TAX_ABATEMENT_KINDS = Object.freeze([
+    'exemption', 'freeze', 'pilot', 'phase_in', 'credit',
+]);
+const TAX_PATH = 'expenses.real_estate_taxes';
+const CURRENCY_DP = CASH_FLOW_VERIFY_DECIMALS.currency;
+function taxIssue(issues, code, section, field, message, value) {
+    issues.push({ code, severity: 'error', section, field, message, ...(value !== undefined ? { value } : {}) });
+}
+const finiteNum = (v) => typeof v === 'number' && Number.isFinite(v);
+const sameMoney = (a, b) => quantizeAtDecimals(a, CURRENCY_DP) === quantizeAtDecimals(b, CURRENCY_DP);
+/**
+ * The shape shared by the `noi_model` reassessment and the `dcf` terminal tax.
+ * Returns the quantum the stated expense must be rounded at, or null when the
+ * object is too malformed to check any further.
+ */
+function checkReassessment(r, issues, section, base) {
+    const trigger = r['trigger'];
+    if (typeof trigger !== 'string' || !REASSESSMENT_TRIGGERS.includes(trigger)) {
+        taxIssue(issues, 'TAX-01', section, `${base}.trigger`, `TAX-01: reassessment.trigger must be one of ${REASSESSMENT_TRIGGERS.join(', ')}`, trigger);
+        return null;
+    }
+    const assessed = r['assessed_value'];
+    const millage = r['millage_rate'];
+    const indicated = r['indicated_tax'];
+    let ok = true;
+    for (const [key, v] of [['assessed_value', assessed], ['millage_rate', millage], ['indicated_tax', indicated]]) {
+        if (!finiteNum(v)) {
+            taxIssue(issues, 'TAX-01', section, `${base}.${key}`, `TAX-01: reassessment.${key} must be a finite number`, v);
+            ok = false;
+        }
+    }
+    if (!ok)
+        return null;
+    // TAX-01: the assessed value follows from the basis and ratio when both are stated.
+    const basis = r['value_basis'];
+    const ratio = r['assessment_ratio'];
+    if (basis !== undefined || ratio !== undefined) {
+        if (!finiteNum(basis) || !finiteNum(ratio)) {
+            taxIssue(issues, 'TAX-01', section, `${base}.assessment_ratio`, 'TAX-01: value_basis and assessment_ratio are stated together or not at all');
+        }
+        else if (!sameMoney(basis * ratio, assessed)) {
+            taxIssue(issues, 'TAX-01', section, `${base}.assessed_value`, `TAX-01: assessed_value ${assessed} must equal value_basis x assessment_ratio (${quantizeAtDecimals(basis * ratio, CURRENCY_DP)})`, assessed);
+        }
+    }
+    // TAX-02: the indicated tax follows from the assessed value and the millage.
+    if (!sameMoney(indicated, assessed * millage)) {
+        taxIssue(issues, 'TAX-02', section, `${base}.indicated_tax`, `TAX-02: indicated_tax ${indicated} must equal assessed_value x millage_rate (${quantizeAtDecimals(assessed * millage, CURRENCY_DP)})`, indicated);
+    }
+    const round = r['round_to_decimals'];
+    if (round !== undefined && !Number.isSafeInteger(round)) {
+        taxIssue(issues, 'TAX-03', section, `${base}.round_to_decimals`, 'TAX-03: round_to_decimals must be an integer; it may be negative to round to a magnitude', round);
+        return null;
+    }
+    return round === undefined ? CURRENCY_DP : round;
+}
+function checkAbatement(a, issues, section, base, stated) {
+    const kind = a['kind'];
+    if (typeof kind !== 'string' || !TAX_ABATEMENT_KINDS.includes(kind)) {
+        taxIssue(issues, 'TAX-06', section, `${base}.kind`, `TAX-06: abatement.kind must be one of ${TAX_ABATEMENT_KINDS.join(', ')}`, kind);
+        return;
+    }
+    const schedule = a['schedule'];
+    if (!Array.isArray(schedule) || schedule.length === 0) {
+        taxIssue(issues, 'TAX-05', section, `${base}.schedule`, 'TAX-05: abatement.schedule must be a nonempty array');
+        return;
+    }
+    const periods = [];
+    let shapeOk = true;
+    for (const [i, row] of schedule.entries()) {
+        const at = `${base}.schedule[${i}]`;
+        if (row === null || typeof row !== 'object' || Array.isArray(row)) {
+            taxIssue(issues, 'TAX-05', section, at, 'TAX-05: each schedule entry must be an object');
+            shapeOk = false;
+            continue;
+        }
+        const e = row;
+        const period = e['period'];
+        if (typeof period !== 'string' || taxPeriodKind(period) === null) {
+            taxIssue(issues, 'TAX-05', section, `${at}.period`, 'TAX-05: period must be an RFC 0041 selector (Y1+, YYYY-Qn, YYYY-MM, or YYYY-MM-DD)', period);
+            shapeOk = false;
+            continue;
+        }
+        periods.push(period);
+        const full = e['full_tax'];
+        const abated = e['abated_tax'];
+        if (!finiteNum(full) || !finiteNum(abated)) {
+            taxIssue(issues, 'TAX-06', section, at, 'TAX-06: full_tax and abated_tax must both be finite numbers');
+            shapeOk = false;
+            continue;
+        }
+        if (abated < 0 || full < 0) {
+            taxIssue(issues, 'TAX-06', section, at, 'TAX-06: full_tax and abated_tax must be nonnegative', abated);
+        }
+        else if (abated > full) {
+            taxIssue(issues, 'TAX-06', section, `${at}.abated_tax`, `TAX-06: abated_tax ${abated} cannot exceed full_tax ${full}`, abated);
+        }
+    }
+    if (!shapeOk)
+        return;
+    // TAX-05: one granularity, strictly increasing, no duplicates.
+    const kinds = new Set(periods.map(p => taxPeriodKind(p)));
+    if (kinds.size > 1) {
+        taxIssue(issues, 'TAX-05', section, `${base}.schedule`, `TAX-05: an abatement schedule uses one period granularity (found ${[...kinds].sort().join(', ')})`);
+        return;
+    }
+    for (let i = 1; i < periods.length; i++) {
+        if (periods[i - 1].localeCompare(periods[i], 'en', { numeric: true }) >= 0) {
+            taxIssue(issues, 'TAX-05', section, `${base}.schedule[${i}].period`, `TAX-05: schedule periods must strictly increase (${periods[i - 1]} then ${periods[i]})`, periods[i]);
+            return;
+        }
+    }
+    // TAX-06: a freeze holds the unabated tax nondecreasing across the schedule.
+    if (kind === 'freeze') {
+        for (let i = 1; i < schedule.length; i++) {
+            const prev = schedule[i - 1]['full_tax'];
+            const cur = schedule[i]['full_tax'];
+            if (cur < prev) {
+                taxIssue(issues, 'TAX-06', section, `${base}.schedule[${i}].full_tax`, `TAX-06: a freeze holds full_tax nondecreasing (${prev} then ${cur})`, cur);
+                return;
+            }
+        }
+    }
+    // TAX-07: the stabilized snapshot ties to one named period of the schedule.
+    const stabilized = a['stabilized_period'];
+    if (stabilized === undefined)
+        return;
+    if (typeof stabilized !== 'string') {
+        taxIssue(issues, 'TAX-07', section, `${base}.stabilized_period`, 'TAX-07: stabilized_period must be a period selector naming a schedule entry', stabilized);
+        return;
+    }
+    const at = periods.indexOf(stabilized);
+    if (at === -1) {
+        taxIssue(issues, 'TAX-07', section, `${base}.stabilized_period`, `TAX-07: stabilized_period ${stabilized} does not name a period in the schedule`, stabilized);
+        return;
+    }
+    if (!finiteNum(stated))
+        return;
+    const abated = schedule[at]['abated_tax'];
+    if (!sameMoney(stated, abated)) {
+        taxIssue(issues, 'TAX-07', section, `${TAX_PATH}.value`, `TAX-07: the stated tax ${stated} must equal the abated tax ${abated} for stabilized_period ${stabilized}`, stated);
+    }
+}
+/** The RFC 0041 selector families, or null when the string is not one. */
+function taxPeriodKind(p) {
+    if (/^Y[1-9]\d*$/.test(p))
+        return 'holding_year';
+    if (/^\d{4}-Q[1-4]$/.test(p))
+        return 'quarter';
+    if (/^\d{4}-(0[1-9]|1[0-2])$/.test(p))
+        return 'month';
+    if (/^\d{4}-\d{2}-\d{2}$/.test(p) && parseISODate(p))
+        return 'date';
+    return null;
+}
+function checkTaxBasis(parsed, issues) {
+    const noi = resolveCrossCheckSection(parsed, 'noi_model').block;
+    if (noi) {
+        const tax = deepGet(noi.content, TAX_PATH);
+        if (tax !== null && typeof tax === 'object' && !Array.isArray(tax)) {
+            const t = tax;
+            const stated = t['value'];
+            const r = t['reassessment'];
+            if (r !== undefined) {
+                if (r === null || typeof r !== 'object' || Array.isArray(r)) {
+                    taxIssue(issues, 'TAX-01', 'noi_model', `${TAX_PATH}.reassessment`, 'TAX-01: reassessment must be an object when stated', r);
+                }
+                else {
+                    const rr = r;
+                    const dp = checkReassessment(rr, issues, 'noi_model', `${TAX_PATH}.reassessment`);
+                    // TAX-03: the stated expense is the indicated tax at the declared quantum.
+                    if (dp !== null && finiteNum(stated) && finiteNum(rr['indicated_tax'])) {
+                        const rounded = quantizeAtDecimals(rr['indicated_tax'], dp);
+                        if (!sameMoney(stated, rounded)) {
+                            taxIssue(issues, 'TAX-03', 'noi_model', `${TAX_PATH}.value`, `TAX-03: the stated tax ${stated} must equal indicated_tax rounded at ${dp} decimals (${rounded})`, stated);
+                        }
+                    }
+                    // TAX-04: the legacy boolean has to agree with the typed trigger.
+                    const flag = t['sale_triggers_reassessment'];
+                    if (typeof flag === 'boolean' && flag !== (rr['trigger'] === 'sale')) {
+                        taxIssue(issues, 'TAX-04', 'noi_model', `${TAX_PATH}.sale_triggers_reassessment`, `TAX-04: sale_triggers_reassessment ${flag} disagrees with reassessment.trigger ${JSON.stringify(rr['trigger'])}`, flag);
+                    }
+                }
+            }
+            const a = t['abatement'];
+            if (a !== undefined) {
+                if (a === null || typeof a !== 'object' || Array.isArray(a)) {
+                    taxIssue(issues, 'TAX-06', 'noi_model', `${TAX_PATH}.abatement`, 'TAX-06: abatement must be an object when stated', a);
+                }
+                else {
+                    checkAbatement(a, issues, 'noi_model', `${TAX_PATH}.abatement`, stated);
+                }
+            }
+        }
+    }
+    // The terminal tax: the next buyer's, after this sale reassesses at the exit
+    // price. No arithmetic is asserted over exit_noi — deriveDCF leaves
+    // exit_value_gross an input because it capitalizes an unstored forward NOI.
+    const dcf = resolveCrossCheckSection(parsed, 'dcf').block;
+    if (!dcf)
+        return;
+    const tt = deepGet(dcf.content, 'exit_analysis.terminal_tax');
+    if (tt === undefined)
+        return;
+    const base = 'exit_analysis.terminal_tax';
+    if (tt === null || typeof tt !== 'object' || Array.isArray(tt)) {
+        taxIssue(issues, 'TAX-01', 'dcf', base, 'TAX-01: terminal_tax must be an object when stated', tt);
+        return;
+    }
+    const t = tt;
+    checkReassessment(t, issues, 'dcf', base);
+    if (typeof t['in_exit_noi'] !== 'boolean') {
+        taxIssue(issues, 'TAX-08', 'dcf', `${base}.in_exit_noi`, 'TAX-08: terminal_tax.in_exit_noi must state whether this tax is already inside exit_noi', t['in_exit_noi']);
+    }
+    // TAX-08: the next buyer is reassessed at what they pay, so the basis is the
+    // exit value — unless the author says in words why it is not.
+    if (t['trigger'] !== 'sale')
+        return;
+    const why = t['value_basis_differs_because'];
+    if (typeof why === 'string' && why.trim().length > 0)
+        return;
+    const gross = deepGet(dcf.content, 'exit_analysis.exit_value_gross');
+    const basis = t['value_basis'];
+    if (!finiteNum(gross) || !finiteNum(basis))
+        return;
+    if (!sameMoney(basis, gross)) {
+        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.
@@ -858,6 +1699,30 @@ function checkStackContent(content, section, prefix, issues) {
                 issues.push({ code: 'CS-02', severity: 'error', section, field: `${prefix}${label}.rate`, message: `CS-02: common_equity tranche ${label} must not state a rate` });
             }
         }
+        // CS-02b: a split coupon is one preferred-equity tranche with two
+        // explicitly typed rate components. Keep the field-presence rule here,
+        // beside CS-02, so schema-valid and hand-built ParsedUWFile inputs receive
+        // the same refusal.
+        const hasCashRate = Object.prototype.hasOwnProperty.call(t, 'cash_rate');
+        const hasAccruedRate = Object.prototype.hasOwnProperty.call(t, 'accrued_rate');
+        if (t['accrual'] === 'split') {
+            if (cls !== 'preferred_equity') {
+                issues.push({ code: 'CS-02b', severity: 'error', section, field: `${prefix}${label}.accrual`, message: `CS-02b: split accrual is supported only for preferred_equity tranche ${label}` });
+            }
+            if (!hasCashRate || !Number.isFinite(t['cash_rate'])) {
+                issues.push({ code: 'CS-02b', severity: 'error', section, field: `${prefix}${label}.cash_rate`, message: `CS-02b: split tranche ${label} must state a numeric cash_rate` });
+            }
+            if (!hasAccruedRate || !Number.isFinite(t['accrued_rate'])) {
+                issues.push({ code: 'CS-02b', severity: 'error', section, field: `${prefix}${label}.accrued_rate`, message: `CS-02b: split tranche ${label} must state a numeric accrued_rate` });
+            }
+            if (hasRate && Number.isFinite(t['cash_rate']) && Number.isFinite(t['accrued_rate'])
+                && t['rate'] !== t['cash_rate'] + t['accrued_rate']) {
+                issues.push({ code: 'CS-02b', severity: 'error', section, field: `${prefix}${label}.rate`, message: `CS-02b: split tranche ${label}.rate must equal cash_rate + accrued_rate` });
+            }
+        }
+        else if (hasCashRate || hasAccruedRate) {
+            issues.push({ code: 'CS-02b', severity: 'error', section, field: `${prefix}${label}.accrual`, message: `CS-02b: cash_rate and accrued_rate are permitted only when tranche ${label} uses accrual: "split"` });
+        }
         // A waterfall smuggled in at the tranche level (promote/hurdle/catch-up).
         for (const key of Object.keys(t)) {
             if (WATERFALL_MARKERS.includes(key)) {
@@ -1291,6 +2156,14 @@ function checkWaterfallContent(content, variant, parsed, issues) {
                         irrOk = true;
                     }
                 }
+                if (t.hurdle_mode != null) {
+                    if (t.hurdle_mode !== 'both' && t.hurdle_mode !== 'any') {
+                        wf01(`tiers[${i}].hurdle_mode`, 'hurdle_mode must be "both" or "any"');
+                    }
+                    else if (t.until_lp_em == null || t.until_lp_irr == null) {
+                        wf01(`tiers[${i}].hurdle_mode`, 'hurdle_mode is only permitted when both until_lp_em and until_lp_irr are stated');
+                    }
+                }
                 if (t.until_lp_em != null || t.until_lp_irr != null) {
                     if ((emOk || irrOk) && !(typeof t.lp_share === 'number' && t.lp_share > 0)) {
                         wf01(`tiers[${i}].lp_share`, 'a capped split must pay the LP (lp_share > 0) or the cap can never bind');
@@ -1383,6 +2256,19 @@ function checkLocale(parsed, issues) {
         value: String(declared),
     });
 }
+// ─── Document currency identity (RFC 0046) ──────────────────────────────────
+function checkCurrencyIdentity(parsed, issues) {
+    const declared = parsed.frontmatter.currency_code;
+    if (declared == null)
+        return; // absent preserves legacy symbol behavior
+    if (isCurrencyCode(declared))
+        return;
+    issues.push({
+        code: 'CUR-01', severity: 'error', field: 'currency_code',
+        message: `CUR-01: currency_code ${JSON.stringify(declared)} is not three uppercase ASCII letters; currency identity is never inferred from locale or a display symbol`,
+        value: declared,
+    });
+}
 // ─── Asset-class identifier (RFC 0003) ───────────────────────────────────────
 /**
  * The identifier itself, independent of whether any module is loaded.