@uwmd/core 2.10.0 → 2.12.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,828 @@ 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);
+        }
+    }
+}
+// ─── §4.3 Expense recoveries and the CAM true-up (RFC 0058) ──────────────────
+//
+// Recovery income is the second-largest line in most commercial deals, and the
+// tenant record carried a lease type and one orphan `cam_cap_pct`. These rules
+// type the terms and check the one piece of arithmetic genuinely knowable from
+// a single document: a closed period's reconciliation.
+//
+// Two things are deliberately NOT recomputed. The cap amount, because a
+// cumulative or compounding cap depends on a base-year history no single
+// document carries — REC-07 checks the direction instead, which is the honest
+// half. And the pool allocation across tenants, because that is a modeling
+// decision with a policy for vacant space, not a recorded fact; each tenant
+// states its own share.
+/** Recovery methods. Closed — a producer meaning something else states `none`. */
+export const RECOVERY_METHODS = Object.freeze([
+    'net', 'base_year_stop', 'fixed_stop', 'fixed_amount', 'none',
+]);
+/**
+ * The §4.4 `operating_statement.expenses` keys a pool may draw from.
+ *
+ * Deliberately excludes `management_fee_pct_egi` (a ratio, not an expense),
+ * `capital_expenditures_actual` and `replacement_reserves` (capital, not
+ * operating), and `total_operating_expenses` (a total — naming it would double
+ * every member beside it).
+ */
+export const RECOVERABLE_EXPENSE_KEYS = Object.freeze([
+    'real_estate_taxes', 'insurance', 'management_fees', 'payroll_benefits',
+    'utilities', 'repairs_maintenance', 'contract_services',
+    'marketing_advertising', 'administrative', 'professional_fees',
+    'other_expenses',
+]);
+export const RECOVERY_CAP_ACCUMULATIONS = Object.freeze([
+    'cumulative', 'non_cumulative', 'compounding',
+]);
+export const RECOVERY_SETTLEMENTS = Object.freeze([
+    'billed', 'credited', 'disputed', 'unsettled',
+]);
+/** Currency quantum, matching every sibling verifier's reporting boundary. */
+const RECOVERY_DP = 2;
+function recIssue(issues, code, field, message, value, severity = 'error') {
+    issues.push({
+        code, severity, section: 'rent_roll', field, message,
+        ...(value !== undefined ? { value } : {}),
+    });
+}
+function roundRec(value) {
+    const f = 10 ** RECOVERY_DP;
+    const scaled = value * f;
+    return (scaled < 0 ? -Math.round(-scaled) : Math.round(scaled)) / f;
+}
+function checkRecoveryTerms(t, issues, at) {
+    const raw = t['recovery_terms'];
+    if (raw == null)
+        return null;
+    const p = `${at}.recovery_terms`;
+    if (typeof raw !== 'object' || Array.isArray(raw)) {
+        recIssue(issues, 'REC-02', p, 'REC-02: recovery_terms must be an object stating a method', raw);
+        return null;
+    }
+    const terms = raw;
+    // REC-01: the share is a fraction, not a percent. 4.12 instead of 0.0412 is
+    // the single most consequential typo available here — it multiplies every
+    // recovery by a hundred.
+    const share = terms['pro_rata_share'];
+    let shareValue = null;
+    if (share != null) {
+        if (!(leaseNum(share) && share > 0 && share <= 1)) {
+            recIssue(issues, 'REC-01', `${p}.pro_rata_share`, 'REC-01: pro_rata_share must be a fraction in (0,1] — 0.0412 is 4.12%, not 4.12', share);
+        }
+        else {
+            shareValue = share;
+        }
+    }
+    // REC-02: a method without the input it needs.
+    const method = terms['method'];
+    if (typeof method !== 'string' || !RECOVERY_METHODS.includes(method)) {
+        recIssue(issues, 'REC-02', `${p}.method`, `REC-02: method must be one of ${RECOVERY_METHODS.join(', ')} — the vocabulary is closed`, method);
+    }
+    else {
+        const REQUIRED = {
+            base_year_stop: 'base_year',
+            fixed_stop: 'expense_stop_per_sqft',
+            fixed_amount: 'fixed_recovery_annual',
+        };
+        const needs = REQUIRED[method];
+        if (needs && terms[needs] == null) {
+            recIssue(issues, 'REC-02', `${p}.${needs}`, `REC-02: method "${method}" requires ${needs}; without it the method states nothing`);
+        }
+    }
+    // REC-03: a pool entry that names nothing recovers nothing, silently.
+    const pool = terms['recoverable_pool'];
+    if (pool != null) {
+        if (!Array.isArray(pool) || pool.length === 0) {
+            recIssue(issues, 'REC-03', `${p}.recoverable_pool`, 'REC-03: recoverable_pool must be a nonempty array of operating-statement expense keys', pool);
+        }
+        else {
+            for (const [j, entry] of pool.entries()) {
+                if (typeof entry !== 'string' || !RECOVERABLE_EXPENSE_KEYS.includes(entry)) {
+                    recIssue(issues, 'REC-03', `${p}.recoverable_pool[${j}]`, `REC-03: ${JSON.stringify(entry)} is not a recoverable operating_statement.expenses key — a pool naming a nonexistent expense recovers zero without saying so`, entry);
+                }
+            }
+        }
+    }
+    // The cap. Accumulation has no default: the three treatments diverge
+    // materially within three years, so a silent choice is a wrong number.
+    const cap = terms['cap'];
+    if (cap != null) {
+        const cp = `${p}.cap`;
+        if (typeof cap !== 'object' || Array.isArray(cap)) {
+            recIssue(issues, 'REC-02', cp, 'REC-02: cap must be an object', cap);
+        }
+        else {
+            const c = cap;
+            const pct = c['pct'];
+            if (pct != null && !(leaseNum(pct) && pct > 0 && pct < 1)) {
+                recIssue(issues, 'REC-01', `${cp}.pct`, 'REC-01: cap.pct must be a fraction in (0,1) — 0.05 is 5%, not 5', pct);
+            }
+            if (pct != null) {
+                const acc = c['accumulation'];
+                if (typeof acc !== 'string' || !RECOVERY_CAP_ACCUMULATIONS.includes(acc)) {
+                    recIssue(issues, 'REC-02', `${cp}.accumulation`, `REC-02: a stated cap.pct requires cap.accumulation (${RECOVERY_CAP_ACCUMULATIONS.join(' | ')}) — there is no default, because the three disagree`, acc);
+                }
+            }
+        }
+    }
+    // REC-10: the legacy field and the typed cap can contradict each other.
+    if (t['cam_cap_pct'] != null && cap != null) {
+        recIssue(issues, 'REC-10', `${at}.cam_cap_pct`, 'REC-10: cam_cap_pct is superseded by recovery_terms.cap; stating both lets the two drift apart', t['cam_cap_pct'], 'warning');
+    }
+    return shareValue;
+}
+/**
+ * REC-09. A settled true-up becomes a dated cash line in §4.26 — the
+ * cross-cutting requirement that new dated cash lands in the addressable sink,
+ * where assembly and receipt coverage already verify it. A reference that
+ * resolves to nothing is the one failure mode that looks like success: the row
+ * claims the amount reached the cash flows, and nothing checks that it did.
+ */
+function recoveryRefResolves(parsed, variant) {
+    const entry = parsed.sections['cash_flow_series'];
+    if (!entry)
+        return false;
+    return isVariantMap(entry)
+        ? entry[variant] !== undefined
+        : variant === 'default';
+}
+function checkRecoveryTrueUp(t, issues, at, share, asOf, parsed) {
+    const rows = t['recovery_true_up'];
+    if (rows == null)
+        return;
+    if (!Array.isArray(rows)) {
+        recIssue(issues, 'REC-04', `${at}.recovery_true_up`, 'REC-04: recovery_true_up must be an array of reconciliation rows', rows);
+        return;
+    }
+    for (const [j, raw] of rows.entries()) {
+        const p = `${at}.recovery_true_up[${j}]`;
+        if (raw === null || typeof raw !== 'object' || Array.isArray(raw)) {
+            recIssue(issues, 'REC-04', p, 'REC-04: each true-up entry must be an object', raw);
+            continue;
+        }
+        const row = raw;
+        const start = row['period_start'];
+        const end = row['period_end'];
+        if (!isDate(start) || !isDate(end)) {
+            recIssue(issues, 'REC-04', `${p}.period_start`, 'REC-04: a true-up states period_start and period_end as YYYY-MM-DD dates');
+            continue;
+        }
+        if (end < start) {
+            recIssue(issues, 'REC-04', `${p}.period_end`, `REC-04: period_end (${end}) precedes period_start (${start})`, end);
+            continue;
+        }
+        // REC-05: a reconciliation of a period that has not ended is a forecast.
+        // Anchored on the rent roll's own as_of_date — never on file metadata,
+        // which is an edit timestamp and would refuse a legitimately re-saved
+        // document. Skipped when the rent roll states no date.
+        if (asOf !== null && !(end < asOf)) {
+            recIssue(issues, 'REC-05', `${p}.period_end`, `REC-05: the true-up period ends ${end}, on or after the rent roll as_of_date ${asOf} — a reconciliation of an open period is a forecast, and this section carries settled facts`, end);
+        }
+        const poolActual = row['pool_actual'];
+        const uncapped = row['tenant_share_uncapped'];
+        const capped = row['tenant_share_capped'];
+        const billed = row['estimated_billed'];
+        const trueUp = row['true_up_amount'];
+        // REC-06: the one product a single document can check.
+        if (leaseNum(poolActual) && share !== null && leaseNum(uncapped)) {
+            const want = roundRec(poolActual * share);
+            if (roundRec(uncapped) !== want) {
+                recIssue(issues, 'REC-06', `${p}.tenant_share_uncapped`, `REC-06: tenant_share_uncapped states ${uncapped} but pool_actual x pro_rata_share is ${want}`, uncapped);
+            }
+        }
+        // REC-07: the cap can only reduce. The capped amount itself is stated,
+        // not recomputed — see the section note.
+        if (leaseNum(uncapped) && leaseNum(capped) && roundRec(capped) > roundRec(uncapped)) {
+            recIssue(issues, 'REC-07', `${p}.tenant_share_capped`, `REC-07: tenant_share_capped (${capped}) exceeds tenant_share_uncapped (${uncapped}) — a cap cannot increase a recovery`, capped);
+        }
+        // REC-08: the subtraction the whole row exists to record.
+        if (leaseNum(capped) && leaseNum(billed) && leaseNum(trueUp)) {
+            const want = roundRec(capped - billed);
+            if (roundRec(trueUp) !== want) {
+                recIssue(issues, 'REC-08', `${p}.true_up_amount`, `REC-08: true_up_amount states ${trueUp} but tenant_share_capped less estimated_billed is ${want}`, trueUp);
+            }
+        }
+        const settlement = row['settlement'];
+        if (settlement != null && !(typeof settlement === 'string' && RECOVERY_SETTLEMENTS.includes(settlement))) {
+            recIssue(issues, 'REC-04', `${p}.settlement`, `REC-04: settlement must be one of ${RECOVERY_SETTLEMENTS.join(', ')}`, settlement);
+        }
+        // REC-09: the §4.26 handoff.
+        const ref = row['cash_flow_ref'];
+        if (ref != null) {
+            const variant = typeof ref === 'object' && !Array.isArray(ref)
+                ? ref['variant']
+                : undefined;
+            if (typeof variant !== 'string' || variant.length === 0) {
+                recIssue(issues, 'REC-09', `${p}.cash_flow_ref`, 'REC-09: cash_flow_ref must name a cash_flow_series variant', ref);
+            }
+            else if (!recoveryRefResolves(parsed, variant)) {
+                recIssue(issues, 'REC-09', `${p}.cash_flow_ref.variant`, `REC-09: cash_flow_ref.variant ${JSON.stringify(variant)} does not resolve to a cash_flow_series variant in this document — the settled amount claims a cash line that is not there`, variant);
+            }
+        }
+    }
+}
+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;
+    const rawAsOf = deepGet(block.content, 'as_of_date');
+    const asOf = isDate(rawAsOf) ? rawAsOf : null;
+    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);
+        const share = checkRecoveryTerms(t, issues, at);
+        checkRecoveryTrueUp(t, issues, at, share, asOf, parsed);
+    }
+}
+// ─── §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.
@@ -1466,6 +2291,54 @@ function sumsToOne(a, b) {
         a >= 0 && a <= 1 && b >= 0 && b <= 1 &&
         Math.abs(a + b - 1) < RATIO_QUANTUM;
 }
+/**
+ * RFC 0059. The clawback is a terminal true-up, so the only structural
+ * questions are whether its basis carries the input it needs, whether the cap
+ * is the one cap that exists, and whether the rates are fractions.
+ */
+function checkWaterfallClawback(content, tiers, section, label, issues) {
+    const raw = content['clawback'];
+    if (raw == null)
+        return;
+    const push = (code, field, message) => {
+        issues.push({ code, severity: 'error', section, field: `clawback.${field}`, message: `${code}: ${message}${label}` });
+    };
+    if (typeof raw !== 'object' || Array.isArray(raw)) {
+        push('WF-10', 'basis', 'clawback must be an object stating a basis and a cap');
+        return;
+    }
+    const cb = raw;
+    const basis = cb['basis'];
+    const BASES = ['lp_preferred_shortfall', 'lp_irr_floor', 'lp_em_floor'];
+    if (typeof basis !== 'string' || !BASES.includes(basis)) {
+        push('WF-10', 'basis', `basis must be one of ${BASES.join(', ')} — the vocabulary is closed`);
+    }
+    else if (basis === 'lp_irr_floor') {
+        const rate = cb['floor_rate'];
+        if (!(typeof rate === 'number' && Number.isFinite(rate) && rate > 0 && rate < 1)) {
+            push('WF-10', 'floor_rate', 'lp_irr_floor requires floor_rate as a fraction in (0,1) — 0.12 is 12%, not 12');
+        }
+    }
+    else if (basis === 'lp_em_floor') {
+        const mult = cb['floor_multiple'];
+        if (!(typeof mult === 'number' && Number.isFinite(mult) && mult > 1)) {
+            push('WF-10', 'floor_multiple', 'lp_em_floor requires floor_multiple greater than 1');
+        }
+    }
+    // WF-11: a preferred-shortfall floor with no preferred tier to measure it.
+    if (basis === 'lp_preferred_shortfall' && !tiers.some((t) => t?.type === 'preferred_return')) {
+        push('WF-11', 'basis', 'lp_preferred_shortfall needs a preferred_return tier — without one there is no accrual to fall short of');
+    }
+    // WF-12: the cap is not a choice.
+    if (cb['cap'] !== 'promote_received') {
+        push('WF-12', 'cap', 'cap must be "promote_received" — a GP cannot owe back more promote than it received, and any other cap is a different instrument');
+    }
+    // WF-13: a stated tax rate is a fraction.
+    const tax = cb['net_of_tax_rate'];
+    if (tax != null && !(typeof tax === 'number' && Number.isFinite(tax) && tax >= 0 && tax < 1)) {
+        push('WF-13', 'net_of_tax_rate', 'net_of_tax_rate must be a fraction in [0,1) — 0.37 is 37%, not 37');
+    }
+}
 function checkWaterfallContent(content, variant, parsed, issues) {
     const section = 'distribution_waterfall';
     const label = variant === 'default' ? '' : ` (variant "${variant}")`;
@@ -1593,6 +2466,8 @@ function checkWaterfallContent(content, variant, parsed, issues) {
             wf01('tiers', 'the ladder must end in at least one split tier');
         }
     }
+    // WF-10 .. WF-15: the RFC 0059 clawback provision.
+    checkWaterfallClawback(content, rows, section, label, issues);
     // WF-02 / WF-03: the cash reference.
     const ref = content['cash_flow_ref'];
     const refVariant = ref && typeof ref['variant'] === 'string' ? ref['variant'] : null;
@@ -1624,6 +2499,19 @@ function checkWaterfallContent(content, variant, parsed, issues) {
             message: `WF-03: the referenced series${label} has no contribution (no negative amount); a waterfall over pure inflows has no capital to return`,
         });
     }
+    // WF-15 (RFC 0059): a clawback provision is unexercisable without a terminal
+    // distribution to have overpaid out of. A warning, not an error — the
+    // provision may legitimately be stated ahead of the exit.
+    if (content['clawback'] != null && Array.isArray(seriesRows)) {
+        const lastPositive = [...seriesRows].reverse().find((r) => r && typeof r === 'object' && typeof r['amount'] === 'number' &&
+            r['amount'] > 0);
+        if (lastPositive === undefined) {
+            issues.push({
+                code: 'WF-15', severity: 'warning', section, field: 'clawback',
+                message: `WF-15: a clawback provision is stated but the referenced series${label} has no distribution, so no promote can have been paid and the provision is unexercisable as stated`,
+            });
+        }
+    }
 }
 function checkWaterfall(parsed, issues) {
     const entry = parsed.sections['distribution_waterfall'];