@mudraforge/statutory 2.11.0 → 2.13.0

package/src/calculators.js

@@ -19,7 +19,7 @@
  */
 
 // Canonical OKF v0.2 Release Merkle Roots & Versions
-export const CURRENT_RELEASE_MERKLE_ROOT = 'sha256-feb1555f10c9f5c70de18ef340e0ba6cf1f060fb19cae866aa36240345c46f3a';
+export const CURRENT_RELEASE_MERKLE_ROOT = 'sha256-b17c37b2724aece2a28beaab5720a777ae27e661ac51f1436be6eff3ca5ef64b';
 export const MERKLE_ROOT_OKF_V2 = CURRENT_RELEASE_MERKLE_ROOT;
 export const STATUTORY_PACKAGE_VERSION = '2.11.0';
 export const OKF_CORPUS_VERSION = '2.11.0';
@@ -51,26 +51,242 @@ export function getRbiBankRateForDate(dateString) {
 // Statutory Multiple per MSMED Act 2006 Section 16: 3x Bank Rate
 export const MSMED_RATE_MULTIPLIER = 3;
 
+/**
+ * Error thrown when a required numeric field cannot be parsed from input.
+ */
+export class MalformedNumericInputError extends Error {
+    constructor(val, fieldName = 'amount') {
+        super(`[@mudraforge/statutory] Malformed numeric input for field "${fieldName}": "${val}". Input could not be safely resolved to a finite number.`);
+        this.name = 'MalformedNumericInputError';
+        this.code = 'MALFORMED_NUMERIC_INPUT';
+        this.field = fieldName;
+        this.rawValue = val;
+    }
+}
+
+/**
+ * Error thrown when a mandatory statutory calculation parameter is missing or null.
+ */
+export class MissingMandatoryParameterError extends Error {
+    constructor(fieldName, functionName) {
+        super(`[@mudraforge/statutory] ${functionName}: Mandatory parameter "${fieldName}" is missing or undefined.`);
+        this.name = 'MissingMandatoryParameterError';
+        this.code = 'MISSING_MANDATORY_PARAMETER';
+        this.field = fieldName;
+        this.functionName = functionName;
+    }
+}
+
+/**
+ * Validates that a required statutory input parameter is present and resolves cleanly
+ * to a finite numeric value, rejecting missing, null, or malformed input without silent coercion.
+ * 
+ * @param {any} val - The input value to validate
+ * @param {string} fieldName - The parameter name for diagnostics
+ * @param {string} functionName - The calling calculator function name
+ * @param {Object} [options]
+ * @param {boolean} [options.interpretCreditAsNegative=false]
+ * @returns {number} Clean normalized number
+ */
+export function assertMandatoryNumeric(val, fieldName, functionName, options = {}) {
+    if (val === undefined || val === null) {
+        throw new MissingMandatoryParameterError(fieldName, functionName);
+    }
+    return cleanNumericAmount(val, {
+        strict: true,
+        fieldName,
+        interpretCreditAsNegative: options.interpretCreditAsNegative || false
+    });
+}
+
+/**
+ * Safely normalizes numeric inputs from numbers, strings with currency symbols (₹, $, €, Rs, INR),
+ * thousands separators (commas), and whitespace into valid finite numbers.
+ * 
+ * Accounting conventions handled:
+ * - Parentheses: "(1,500.00)" or "(₹ 1,500.00)" -> -1500.00
+ * - Trailing minus: "1,500.00-" -> -1500.00
+ * - Leading minus with spaces: "- ₹ 1,500.00" -> -1500.00
+ * - Credit suffix: "1,500.00 CR" -> magnitude 1500.00. Negated only if interpretCreditAsNegative: true.
+ * - Negative zero (-0) normalized to unsigned 0.
+ * 
+ * @param {any} val - Input number or formatted numeric string
+ * @param {Object} [options]
+ * @param {boolean} [options.strict=false] - When true, throws MalformedNumericInputError on unparseable strings
+ * @param {string} [options.fieldName='amount'] - Diagnostic field name for error reporting
+ * @param {boolean} [options.interpretCreditAsNegative=false] - Whether "CR" suffix inverts sign
+ * @returns {number} Normalized float
+ */
+export function cleanNumericAmount(val, options = {}) {
+    const {
+        strict = false,
+        fieldName = 'amount',
+        interpretCreditAsNegative = false,
+        defaultValue = 0
+    } = options;
+
+    if (typeof val === 'number') {
+        if (!Number.isFinite(val) || isNaN(val)) {
+            if (strict) {
+                throw new MalformedNumericInputError(val, fieldName);
+            }
+            return defaultValue;
+        }
+        return Object.is(val, -0) ? 0 : val;
+    }
+    if (val === null || val === undefined || typeof val === 'boolean') {
+        return defaultValue;
+    }
+    if (typeof val === 'string') {
+        const trimmed = val.trim();
+        if (!trimmed) return defaultValue;
+
+        let isNegative = false;
+        let s = trimmed;
+
+        // Financial malformation checks:
+        // 1. Digits separated by whitespace (e.g. "100 200" or concatenated invoice numbers)
+        // 2. Double commas or double decimal points (e.g. "1,,000" or "100..50")
+        // 3. Comma appearing after a decimal point (e.g. "100.50,25")
+        if (/\d\s+\d/.test(s) || /(?:,,|\.\.)/.test(s) || /\.\d*,/.test(s)) {
+            if (strict) {
+                throw new MalformedNumericInputError(val, fieldName);
+            }
+            return defaultValue;
+        }
+
+        // Strip leading currency label before parenthesis or sign: "₹ (50,000.00)" or "INR -50,000"
+        s = s.replace(/^(?:₹|\$|€|INR|Rs\.?)\s*/i, '');
+
+        // Accounting parentheses: (1,500.00) or (₹ 1,500.00)
+        if (/^\(.*\)$/.test(s)) {
+            isNegative = true;
+            s = s.slice(1, -1).trim();
+        } else if (/-\s*$/.test(s)) {
+            // Trailing minus from legacy ERP dumps: "1,500.00-"
+            isNegative = true;
+            s = s.replace(/-\s*$/, '').trim();
+        } else if (/^\s*-\s*/.test(s)) {
+            // Explicit leading minus with possible whitespace: "- ₹ 1,500.00" or "-1500"
+            isNegative = true;
+            s = s.replace(/^\s*-\s*/, '').trim();
+        } else if (/(?:\s+)?(?:cr|credit)\.?$/i.test(s)) {
+            // Accounting credit suffix: "1,500.00 CR"
+            // Note: CR means credit, whose signed interpretation depends on ledger orientation.
+            // Only negate if caller explicitly requests interpretCreditAsNegative: true.
+            if (interpretCreditAsNegative) {
+                isNegative = true;
+            }
+            s = s.replace(/(?:\s+)?(?:cr|credit)\.?$/i, '').trim();
+        } else if (/(?:\s+)?(?:dr|debit)\.?$/i.test(s)) {
+            // Accounting debit suffix: "1,500.00 DR"
+            s = s.replace(/(?:\s+)?(?:dr|debit)\.?$/i, '').trim();
+        }
+
+        // Strip remaining currency symbols, commas, and currency labels
+        const cleaned = s.replace(/[₹$€,\s]|(?:INR|Rs\.?)/gi, '');
+        const n = parseFloat(cleaned);
+        
+        // Check for malformed strings that had non-numeric text left over
+        const isCleanNumber = /^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?$/.test(cleaned);
+        if (!isCleanNumber || !Number.isFinite(n) || isNaN(n)) {
+            if (strict) {
+                throw new MalformedNumericInputError(val, fieldName);
+            }
+            return defaultValue;
+        }
+
+        const res = isNegative ? -Math.abs(n) : n;
+        return Object.is(res, -0) ? 0 : res;
+    }
+    return defaultValue;
+}
+
+/**
+ * High-precision conversion of rupees to integer paise.
+ * Avoids IEEE-754 floating point drift during threshold and summation operations.
+ * 
+ * Safety Bounds & Precision Policy:
+ * - Bounds: Asserts absolute value does not exceed JavaScript Number.MAX_SAFE_INTEGER (53-bit integer limit).
+ * - Precision: Applies standard statutory half-up rounding (Math.round) to the nearest integer paisa.
+ * - Strict sub-paisa: When options.strictSubPaisa is true, rejects amounts having fractional sub-paisa (>2 decimals).
+ * 
+ * @param {any} amount - Rupees amount or formatted string
+ * @param {string|Object} [options='amount'] - Diagnostic field name or options object
+ * @param {string} [options.fieldName='amount']
+ * @param {boolean} [options.strict=false]
+ * @param {boolean} [options.strictSubPaisa=false]
+ * @returns {number} Integer paise (e.g. 50.25 -> 5025)
+ */
+export function toIntegerPaise(amount, options = 'amount') {
+    const opts = typeof options === 'string' ? { fieldName: options } : (options || {});
+    const {
+        fieldName = 'amount',
+        strict = false,
+        strictSubPaisa = false
+    } = opts;
+
+    const n = cleanNumericAmount(amount, { strict, fieldName });
+    const rawPaise = n * 100;
+
+    // Safe integer boundary assertion (9 quadrillion paise / ~₹90 Trillion limit)
+    if (Math.abs(rawPaise) > Number.MAX_SAFE_INTEGER) {
+        throw new RangeError(`[@mudraforge/statutory] Amount exceeds JavaScript MAX_SAFE_INTEGER (53-bit limit) in field "${fieldName}".`);
+    }
+
+    const roundedPaise = Math.round(rawPaise);
+
+    // Explicit sub-paisa fractional detection
+    if (strictSubPaisa && Math.abs(rawPaise - roundedPaise) > 1e-4) {
+        throw new MalformedNumericInputError(amount, fieldName);
+    }
+
+    return roundedPaise;
+}
+
+/**
+ * Converts integer paise back to rupees with 2 decimal places.
+ * 
+ * Safety Bounds:
+ * - Asserts input paise does not exceed Number.MAX_SAFE_INTEGER.
+ * 
+ * @param {number} paise - Integer paise
+ * @returns {number} Rounded rupees
+ */
+export function fromIntegerPaise(paise) {
+    if (!Number.isFinite(paise) || isNaN(paise)) return 0;
+    if (Math.abs(paise) > Number.MAX_SAFE_INTEGER) {
+        throw new RangeError('[@mudraforge/statutory] Integer paise exceeds JavaScript MAX_SAFE_INTEGER (53-bit limit).');
+    }
+    const rupees = paise / 100;
+    return Object.is(rupees, -0) ? 0 : Math.round(rupees * 100) / 100;
+}
+
 /**
  * Standard Paisa Precision Rounding (2 decimal places) using integer math.
  * Eliminates floating point drift (e.g. 0.00000000001).
  * Rejects negative zero (-0 normalized to 0).
  */
 export function roundToPaisa(amount) {
-    const n = Number(amount);
+    const n = cleanNumericAmount(amount);
     if (!Number.isFinite(n) || isNaN(n) || Object.is(n, -0)) return 0;
-    return Math.round(n * 100) / 100;
+    return fromIntegerPaise(Math.round(n * 100));
 }
 
 /**
  * Section 288B Rounding (Rounding off of tax):
- * The amount of tax under the Income-tax Act is rounded off to the nearest rupee,
- * and if the fraction is 50 paise or more, it is rounded up; otherwise ignored.
+ * Under Section 288B of the Income-tax Act, 1961 (as substituted by the Taxation Laws
+ * (Amendment) Act, 2006 w.e.f. 13-07-2006), the amount of tax payable/deductible,
+ * interest, penalty or refund is rounded off to the nearest multiple of ten rupees:
+ * 1. Part of a rupee consisting of paise: >= 50 paise is rounded up to ₹1, < 50 paise ignored.
+ * 2. If the last digit of the resulting whole rupees is 5 or more, increased to next higher multiple of ₹10.
+ * 3. If the last digit is less than 5, reduced to next lower multiple of ₹10.
  */
 export function roundSection288B(amount) {
-    const n = Number(amount);
+    const n = cleanNumericAmount(amount);
     if (!Number.isFinite(n) || isNaN(n) || Object.is(n, -0)) return 0;
-    return Math.round(n);
+    const wholeRupees = Math.round(n);
+    return Math.round(wholeRupees / 10) * 10;
 }
 
 /**
@@ -102,9 +318,9 @@ export function calculateMsmeCompoundInterest({
     dateConvention = 'START_DATE_INCLUSIVE', // 'START_DATE_INCLUSIVE' | 'SECTION_16_DAY_AFTER_DUE' | 'FROM_APPOINTED_DAY' | 'FROM_DAY_AFTER_AGREED_DATE'
     commenceDayAfter = false, // Legacy flag: when true, adds 1 day to dueDate per Section 16 agreed date rule
     includePaymentDate = false // When false, payment date is the settlement day (interest ceases at start of payment date)
-}) {
-    const p = Number(principal);
-    if (isNaN(p) || p <= 0) {
+} = {}) {
+    const p = assertMandatoryNumeric(principal, 'principal', 'calculateMsmeCompoundInterest');
+    if (p <= 0) {
         throw new Error("Invalid principal amount for MSME interest calculation.");
     }
 
@@ -488,7 +704,7 @@ export function evaluateSection43bH({
     fyEndDate = null,
     supplierType = 'MANUFACTURER', // 'MICRO_MANUFACTURER', 'SMALL_MANUFACTURER', 'TRADER', 'MEDIUM'
     nicCode = null
-}) {
+} = {}) {
     const baseAcceptanceDate = new Date(acceptanceDate || invoiceDate);
     
     // Dynamically calculate fiscal year end based on invoice/acceptance date if not explicitly overridden
@@ -987,9 +1203,10 @@ export function evaluateCrossBorderRemittance({
     hasNoPe = false,
     hasForm10F = false,
     hasAoCertificate = false
-}) {
-    const usd = Number(amountUsd);
-    const amountInr = Number((usd * fxRate).toFixed(2));
+} = {}) {
+    const usd = cleanNumericAmount(amountUsd);
+    const rate = cleanNumericAmount(fxRate) || 83.5;
+    const amountInr = roundToPaisa(usd * rate);
     const txDate = new Date(transactionDate);
 
     // If treaty relief is claimed (TRC, No-PE, or Form 10F) but country is missing,
@@ -1355,8 +1572,8 @@ export function resolveMissingPanPenaltyFloor({
     const sec = String(sectionCode || '').toUpperCase().trim();
     const item = String(tableItem || '').toLowerCase().trim();
 
-    const isGoodsPurchase = sec === '194Q' || item === '393_8_ii' || item === 'item 8(ii)' || item === '8(ii)';
-    const isEcommerce = sec === '194O' || sec === '194-O' || item === '393_8_v' || item === 'item 8(v)' || item === '8(v)';
+    const isGoodsPurchase = sec === '194Q' || item === '393_8_ii' || item === '393_1_8_ii' || item === 'sl 8(ii)' || item === 'sl. no. 8(ii)' || item === 'item 8(ii)' || item === '8(ii)';
+    const isEcommerce = sec === '194O' || sec === '194-O' || item === '393_8_v' || item === '393_1_8_i' || item === 'sl 8(i)' || item === 'sl. no. 8(i)' || item === 'item 8(v)' || item === '8(v)' || item === '8(i)';
 
     if (isGoodsPurchase || isEcommerce) {
         return {
@@ -1364,7 +1581,7 @@ export function resolveMissingPanPenaltyFloor({
             isConcessional5PercentApplicable: true,
             categoryScope: isGoodsPurchase ? 'SPECIFIED_GOODS_PURCHASE_5_PERCENT' : 'SPECIFIED_ECOMMERCE_PARTICIPANT_5_PERCENT',
             governingProviso: isAct2025
-                ? `Income-tax Act, 2025 Section 397(2)(b)(i)(${isGoodsPurchase ? 'C' : 'D'}) read with Section 393(1) Table 8, Item ${isGoodsPurchase ? '8(ii)' : '8(v)'}`
+                ? `Income-tax Act, 2025 Section 397(2)(b)(i)(${isGoodsPurchase ? 'C' : 'D'}) read with Section 393(1), Table 1, Sl. No. ${isGoodsPurchase ? '8(ii)' : '8(i)'}`
                 : `Income-tax Act, 1961 Section 206AA(1) First Proviso read with Section ${sec}`
         };
     }
@@ -1579,11 +1796,11 @@ export function evaluateSection194Q({
     rateEffectiveFrom = null,
     rateEffectiveTo = null
 } = {}) {
-    const rawInvoiceAmount = Number(invoiceAmount) || 0;
-    const gstAmount = Number(gstAmountInr) || 0;
-    const creditNote = Number(creditNoteInr) || 0;
-    const advanceNetted = Number(advanceNettedInr) || 0;
-    const priorAdvanceTds = Number(priorAdvanceTdsDeductedInr) || 0;
+    const rawInvoiceAmount = assertMandatoryNumeric(invoiceAmount, 'invoiceAmount', 'evaluateSection194Q');
+    const gstAmount = cleanNumericAmount(gstAmountInr);
+    const creditNote = cleanNumericAmount(creditNoteInr);
+    const advanceNetted = cleanNumericAmount(advanceNettedInr);
+    const priorAdvanceTds = cleanNumericAmount(priorAdvanceTdsDeductedInr);
 
     // CBDT Circular No. 13 of 2021 Question 3:
     // Does Section 194Q apply to import of goods from non-residents?
@@ -1642,13 +1859,17 @@ export function evaluateSection194Q({
     // Disambiguate Current FY purchases vs Preceding FY purchases:
     // Section 194Q(1) statutory threshold evaluates cumulative purchases in the CURRENT previous year (current FY).
     // Purchases from the preceding financial year do NOT consume the current financial year threshold.
-    const prior = Math.max(0, Number(
+    const prior = Math.max(0, cleanNumericAmount(
         currentFyPriorPurchasesInr !== undefined
             ? currentFyPriorPurchasesInr
             : (priorPurchasesInCurrentFyInr !== undefined ? priorPurchasesInCurrentFyInr : priorFyPurchases)
-    ) || 0);
-    const cumulative = prior + amount;
+    ));
     const THRESHOLD = 5000000; // ₹50 Lakhs
+    const THRESHOLD_PAISE = 500000000; // ₹50 Lakhs in integer paise
+    const priorPaise = toIntegerPaise(prior, 'priorPurchases');
+    const amountPaise = toIntegerPaise(amount, 'amount');
+    const cumulativePaise = priorPaise + amountPaise;
+    const cumulative = fromIntegerPaise(cumulativePaise);
 
     // Buyer turnover prescription under Section 194Q(1) Explanation:
     // Person whose total sales, gross receipts or turnover exceeds ₹10 Crore in preceding FY.
@@ -1672,8 +1893,10 @@ export function evaluateSection194Q({
     // Incremental threshold absorption formula with Paisa integer precision:
     // Delta = max(0, cumulative - THRESHOLD) - max(0, prior - THRESHOLD)
     // Taxable base is min(amount, Delta)
-    const incrementalExcess = roundToPaisa(Math.max(0, cumulative - THRESHOLD) - Math.max(0, prior - THRESHOLD));
-    const conditionalTaxableBase = roundToPaisa(Math.max(0, Math.min(amount, incrementalExcess)));
+    const incrementalExcessPaise = Math.max(0, cumulativePaise - THRESHOLD_PAISE) - Math.max(0, priorPaise - THRESHOLD_PAISE);
+    const conditionalTaxableBasePaise = Math.max(0, Math.min(amountPaise, incrementalExcessPaise));
+    const conditionalTaxableBase = fromIntegerPaise(conditionalTaxableBasePaise);
+    const incrementalExcess = fromIntegerPaise(incrementalExcessPaise);
     const taxableBase = isSection194QApplicable 
         ? conditionalTaxableBase 
         : (isBuyerPrescriptionIndeterminate ? conditionalTaxableBase : 0);
@@ -1726,7 +1949,7 @@ export function evaluateSection194Q({
         isAct2025 = effectiveDate >= '2026-04-01';
         isPost206cSunset = effectiveDate >= '2025-04-01';
         governingWithholdingSection = isSection194QApplicable || isBuyerPrescriptionIndeterminate
-            ? (isAct2025 ? "Income-tax Act, 2025 Section 393(1) Table 8, Item (ii)" : "Income-tax Act, 1961 Section 194Q")
+            ? (isAct2025 ? "Income-tax Act, 2025 Section 393(1), Table 1, Sl. No. 8(ii)" : "Income-tax Act, 1961 Section 194Q")
             : "N/A (Buyer turnover does not exceed ₹10 Cr threshold)";
     } else {
         // Date is missing: preserve uncertainty rather than coercing machine date
@@ -1734,12 +1957,12 @@ export function evaluateSection194Q({
         isAct2025 = false;
         isPost206cSunset = true; // Section 206C(1H) sunset on 1 April 2025
         governingWithholdingSection = isSection194QApplicable || isBuyerPrescriptionIndeterminate
-            ? "Income-tax Act, 1961 Section 194Q (or Income-tax Act, 2025 Section 393(1) Table 8, Item 8(ii) if credited/paid on or after 1 April 2026)"
+            ? "Income-tax Act, 1961 Section 194Q (or Income-tax Act, 2025 Section 393(1), Table 1, Sl. No. 8(ii) if credited/paid on or after 1 April 2026)"
             : "N/A (Buyer turnover does not exceed ₹10 Cr threshold)";
     }
 
     let governingPanPenaltySection = isAct2025 
-        ? "Income-tax Act, 2025 Section 397(2)(b)(i)(C) read with Section 393(1) Table 8, Item 8(ii)" 
+        ? "Income-tax Act, 2025 Section 397(2)(b)(i)(C) read with Section 393(1), Table 1, Sl. No. 8(ii)" 
         : "Income-tax Act, 1961 Section 206AA(1) First Proviso read with Section 194Q";
     
     // Resolve certificate framework with Section 536(2) transitional savings and validity evaluation
@@ -1923,6 +2146,7 @@ export function evaluateSection194Q({
         statutoryRatePercent,
         effectiveRatePercent,
         calculatedTdsInr,
+        taxAmountRoundedSection288B: roundSection288B(calculatedTdsInr),
         certifiedTdsInr,
         uncoveredTdsInr,
         certificateCeiling,
@@ -2344,15 +2568,15 @@ export function evaluateSection194C({
     certificatePriorUtilizedInr = 0,
     certificateSection = null
 } = {}) {
-    const rawInvoiceAmount = Number(invoiceAmount) || 0;
-    const gstAmount = Number(gstAmountInr) || 0;
+    const rawInvoiceAmount = assertMandatoryNumeric(invoiceAmount, 'invoiceAmount', 'evaluateSection194C');
+    const gstAmount = cleanNumericAmount(gstAmountInr);
 
     // CBDT Circular No. 23/2017: If GST is separately stated, TDS applies to basic value
     const effectiveContractAmount = isAdvancePayment
         ? rawInvoiceAmount
         : Math.max(0, rawInvoiceAmount - gstAmount);
 
-    const prior = Math.max(0, Number(priorFyPayments) || 0);
+    const prior = Math.max(0, cleanNumericAmount(priorFyPayments));
     const cumulative = prior + effectiveContractAmount;
 
     const SINGLE_THRESHOLD = 30000;
@@ -2438,7 +2662,7 @@ export function evaluateSection194C({
     // ── Temporal Act Bridge ──
     const isAct2025 = effectiveDate ? effectiveDate >= '2026-04-01' : false;
     const governingSection = isAct2025
-        ? "Income-tax Act, 2025 Section 393(1) Table 6, Item (i)"
+        ? "Income-tax Act, 2025 Section 393(1), Table 1, Sl. No. 6(i)"
         : "Income-tax Act, 1961 Section 194C";
     
     // Resolve certificate framework with Section 536(2) transitional savings and validity evaluation
@@ -2580,6 +2804,7 @@ export function evaluateSection194C({
         standardRatePercent,
         effectiveRatePercent,
         calculatedTdsInr,
+        taxAmountRoundedSection288B: roundSection288B(calculatedTdsInr),
         certifiedTdsInr,
         uncoveredTdsInr,
         certificateCeiling,
@@ -2686,14 +2911,14 @@ export function evaluateSection194J({
     certificatePriorUtilizedInr = 0,
     certificateSection = null
 } = {}) {
-    const rawInvoiceAmount = Number(invoiceAmount) || 0;
-    const gstAmount = Number(gstAmountInr) || 0;
-
     const normalizedCategory = normalize194JCategory(serviceCategory);
     if (!normalizedCategory) {
         throw new Error(`INVALID_SERVICE_CATEGORY: Unknown serviceCategory "${serviceCategory}". Allowed categories: ${VALID_194J_CATEGORIES.join(', ')}`);
     }
 
+    const rawInvoiceAmount = assertMandatoryNumeric(invoiceAmount, 'invoiceAmount', 'evaluateSection194J');
+    const gstAmount = cleanNumericAmount(gstAmountInr);
+
     // CBDT Circular No. 23/2017: If GST is separately stated, TDS applies to basic value
     const effectiveServiceAmount = isAdvancePayment
         ? rawInvoiceAmount
@@ -2702,7 +2927,7 @@ export function evaluateSection194J({
     const effectivePriorInput = priorPaymentsInCurrentFyInr !== null && priorPaymentsInCurrentFyInr !== undefined
         ? priorPaymentsInCurrentFyInr
         : priorFyCategoryPayments;
-    const prior = Math.max(0, Number(effectivePriorInput) || 0);
+    const prior = Math.max(0, cleanNumericAmount(effectivePriorInput));
     const cumulative = prior + effectiveServiceAmount;
 
     const isDirectorFee = normalizedCategory === 'DIRECTOR_REMUNERATION';
@@ -2748,9 +2973,9 @@ export function evaluateSection194J({
 
     // ── Temporal Act Bridge ──
     const isAct2025 = Boolean(effectiveDate && String(effectiveDate).slice(0, 10) >= '2026-04-01');
-    const governingSection = isAct2025
-        ? "Income-tax Act, 2025 Section 393(1) Table 6, Item (iii)"
-        : "Income-tax Act, 1961 Section 194J";
+    const governingSection = isDirectorFee
+        ? (isAct2025 ? "Income-tax Act, 2025 Section 393(1), Table 1, Sl. No. 6(iii) (Director Remuneration)" : "Income-tax Act, 1961 Section 194J(1)(ba)")
+        : (isAct2025 ? "Income-tax Act, 2025 Section 393(1), Table 1, Sl. No. 6(iii)" : "Income-tax Act, 1961 Section 194J");
 
     // ── Rate Determination ──
     // 2% for FTS, BPO, Royalty; 10% for Professional Services, Non-compete, and Director fees
@@ -2767,7 +2992,9 @@ export function evaluateSection194J({
 
     // ── Threshold Evaluation ──
     // Director remuneration has NO threshold under 3rd proviso to Section 194J(1)
-    const CATEGORY_THRESHOLD = isDirectorFee ? 0 : 30000;
+    // Director remuneration has NO threshold under 3rd proviso to Section 194J(1) / Section 393(1) Table 1 Sl. No. 6(iii)
+    // 1961 Act threshold: ₹30,000; 2025 Act threshold: ₹50,000 (Section 393(1), Table 1, Sl. No. 6(iii))
+    const CATEGORY_THRESHOLD = isDirectorFee ? 0 : (isAct2025 ? 50000 : 30000);
     const isThresholdBreached = isDirectorFee || cumulative > CATEGORY_THRESHOLD;
 
     let taxableBase = 0;
@@ -2904,6 +3131,7 @@ export function evaluateSection194J({
         standardRatePercent,
         effectiveRatePercent,
         calculatedTdsInr,
+        taxAmountRoundedSection288B: roundSection288B(calculatedTdsInr),
         certifiedTdsInr,
         uncoveredTdsInr,
         certificateCeiling,
@@ -2945,6 +3173,8 @@ export function evaluateSection194J({
  */
 export function evaluateSection194I({
     invoiceAmount,
+    monthlyRent = null,
+    rentPeriodMonths = null,
     priorFyRent = 0,
     priorFyPayments = null,
     priorFyPaymentsAlreadyTaxed = null,
@@ -2962,16 +3192,16 @@ export function evaluateSection194I({
     certificatePriorUtilizedInr = 0,
     certificateSection = null
 } = {}) {
-    const rawInvoiceAmount = Number(invoiceAmount) || 0;
-    const gstAmount = Number(gstAmountInr) || 0;
+    const rawInvoiceAmount = assertMandatoryNumeric(invoiceAmount, 'invoiceAmount', 'evaluateSection194I');
+    const gstAmount = cleanNumericAmount(gstAmountInr);
 
     const effectiveRentAmount = isAdvancePayment
         ? rawInvoiceAmount
         : Math.max(0, rawInvoiceAmount - gstAmount);
 
     const effectivePrior = priorFyPayments !== null && priorFyPayments !== undefined
-        ? Number(priorFyPayments) || 0
-        : Number(priorFyRent) || 0;
+        ? cleanNumericAmount(priorFyPayments)
+        : cleanNumericAmount(priorFyRent);
     const prior = Math.max(0, effectivePrior);
     const cumulative = prior + effectiveRentAmount;
 
@@ -3003,7 +3233,7 @@ export function evaluateSection194I({
 
     const isAct2025 = Boolean(effectiveDate && String(effectiveDate).slice(0, 10) >= '2026-04-01');
     const governingSection = isAct2025
-        ? "Income-tax Act, 2025 Section 393(1) Table 8, Item 5"
+        ? "Income-tax Act, 2025 Section 393(1), Table 1, Sl. No. 2"
         : "Income-tax Act, 1961 Section 194I";
 
     const panAvailable = Boolean(hasPan) && !isPanInoperative;
@@ -3014,8 +3244,16 @@ export function evaluateSection194I({
     });
     const standardRatePercent = panAvailable ? baseStatutoryRatePercent : Math.max(baseStatutoryRatePercent, panFloorResolution.penaltyFloorPercent);
 
-    // Threshold: ₹2,40,000 per financial year
-    const RENT_THRESHOLD = 240000;
+    // Threshold: Under 1961 Act: ₹2,40,000 per financial year; Under 2025 Act: ₹50,000 per month or part thereof (Section 393(1), Table 1, Sl. No. 2)
+    let RENT_THRESHOLD;
+    if (isAct2025) {
+        const effectiveRentMonths = (rentPeriodMonths !== null && rentPeriodMonths !== undefined && !isNaN(Number(rentPeriodMonths)) && Number(rentPeriodMonths) > 0)
+            ? Number(rentPeriodMonths)
+            : null;
+        RENT_THRESHOLD = effectiveRentMonths ? (50000 * effectiveRentMonths) : 50000;
+    } else {
+        RENT_THRESHOLD = 240000;
+    }
     const isThresholdBreached = cumulative > RENT_THRESHOLD;
 
     let taxableBase = 0;
@@ -3119,16 +3357,16 @@ export function evaluateSection194H({
     certificatePriorUtilizedInr = 0,
     certificateSection = null
 } = {}) {
-    const rawInvoiceAmount = Number(invoiceAmount) || 0;
-    const gstAmount = Number(gstAmountInr) || 0;
+    const rawInvoiceAmount = assertMandatoryNumeric(invoiceAmount, 'invoiceAmount', 'evaluateSection194H');
+    const gstAmount = cleanNumericAmount(gstAmountInr);
 
     const effectiveCommissionAmount = isAdvancePayment
         ? rawInvoiceAmount
         : Math.max(0, rawInvoiceAmount - gstAmount);
 
     const effectivePrior = priorFyPayments !== null && priorFyPayments !== undefined
-        ? Number(priorFyPayments) || 0
-        : Number(priorFyCommission) || 0;
+        ? cleanNumericAmount(priorFyPayments)
+        : cleanNumericAmount(priorFyCommission);
     const prior = Math.max(0, effectivePrior);
     const cumulative = prior + effectiveCommissionAmount;
 
@@ -3160,7 +3398,7 @@ export function evaluateSection194H({
     const baseStatutoryRatePercent = isPostOctober2024 ? 2.0 : 5.0;
 
     const governingSection = isAct2025
-        ? "Income-tax Act, 2025 Section 393(1) Table 8, Item 4"
+        ? "Income-tax Act, 2025 Section 393(1), Table 1, Sl. No. 1(ii)"
         : "Income-tax Act, 1961 Section 194H";
 
     const panAvailable = Boolean(hasPan) && !isPanInoperative;
@@ -3171,8 +3409,8 @@ export function evaluateSection194H({
     });
     const standardRatePercent = panAvailable ? baseStatutoryRatePercent : Math.max(baseStatutoryRatePercent, panFloorResolution.penaltyFloorPercent);
 
-    // Threshold: ₹15,000 per financial year
-    const COMMISSION_THRESHOLD = 15000;
+    // Threshold: ₹15,000 under 1961 Act; ₹20,000 under 2025 Act Section 393(1), Table 1, Sl. No. 1(ii)
+    const COMMISSION_THRESHOLD = isAct2025 ? 20000 : 15000;
     const isThresholdBreached = cumulative > COMMISSION_THRESHOLD;
 
     let taxableBase = 0;
@@ -3286,12 +3524,12 @@ export function evaluateSection194A({
     certificatePriorUtilizedInr = 0,
     certificateSection = null
 } = {}) {
-    const rawInterestAmount = Number(interestAmount) || 0;
+    const rawInterestAmount = assertMandatoryNumeric(interestAmount, 'interestAmount', 'evaluateSection194A');
 
     const effectivePriorInput = priorPaymentsInCurrentFyInr !== null && priorPaymentsInCurrentFyInr !== undefined
         ? priorPaymentsInCurrentFyInr
         : priorFyCategoryPayments;
-    const prior = Math.max(0, Number(effectivePriorInput) || 0);
+    const prior = Math.max(0, cleanNumericAmount(effectivePriorInput));
     const cumulative = prior + rawInterestAmount;
 
     // Temporal Resolution: "Credit or Payment, whichever is earlier"
@@ -3315,20 +3553,35 @@ export function evaluateSection194A({
     }
 
     const isAct2025 = Boolean(effectiveDate && String(effectiveDate).slice(0, 10) >= '2026-04-01');
-    const governingSection = isAct2025
-        ? "Income-tax Act, 2025 Section 393(1) Table 4, Item (i)"
-        : "Income-tax Act, 1961 Section 194A";
 
     // Payee Category & Threshold Resolution
     const isExemptInstitution = payeeCategory === 'EXEMPT_INSTITUTION';
     const isFirmToPartner = payeeCategory === 'FIRM_TO_PARTNER';
     const isStatutoryExclusion = isExemptInstitution || isFirmToPartner;
 
-    let INTEREST_THRESHOLD = 5000;
-    if (payeeCategory === 'BANKING_OR_COOPERATIVE') {
-        INTEREST_THRESHOLD = 40000;
-    } else if (payeeCategory === 'SENIOR_CITIZEN_DEPOSIT') {
-        INTEREST_THRESHOLD = 50000;
+    let INTEREST_THRESHOLD;
+    let governingSection;
+
+    if (isAct2025) {
+        if (payeeCategory === 'SENIOR_CITIZEN_DEPOSIT') {
+            INTEREST_THRESHOLD = 100000;
+            governingSection = "Income-tax Act, 2025 Section 393(1), Table 1, Sl. No. 5(ii)";
+        } else if (payeeCategory === 'BANKING_OR_COOPERATIVE') {
+            INTEREST_THRESHOLD = 50000;
+            governingSection = "Income-tax Act, 2025 Section 393(1), Table 1, Sl. No. 5(ii)";
+        } else {
+            INTEREST_THRESHOLD = 10000;
+            governingSection = "Income-tax Act, 2025 Section 393(1), Table 1, Sl. No. 5(iii)";
+        }
+    } else {
+        if (payeeCategory === 'SENIOR_CITIZEN_DEPOSIT') {
+            INTEREST_THRESHOLD = 50000;
+        } else if (payeeCategory === 'BANKING_OR_COOPERATIVE') {
+            INTEREST_THRESHOLD = 40000;
+        } else {
+            INTEREST_THRESHOLD = 5000;
+        }
+        governingSection = "Income-tax Act, 1961 Section 194A";
     }
 
     const isThresholdBreached = !isStatutoryExclusion && (cumulative > INTEREST_THRESHOLD);
@@ -3480,14 +3733,14 @@ export function evaluateSection194O({
     certificatePriorUtilizedInr = 0,
     certificateSection = null
 } = {}) {
-    const rawGrossSale = Number(grossSaleAmount) || 0;
-    const deemedDirectPayment = Math.max(0, Number(directPurchaserPaymentDeemedInr) || 0);
+    const rawGrossSale = assertMandatoryNumeric(grossSaleAmount, 'grossSaleAmount', 'evaluateSection194O');
+    const deemedDirectPayment = Math.max(0, cleanNumericAmount(directPurchaserPaymentDeemedInr));
     const totalTransactionGmv = rawGrossSale + deemedDirectPayment;
 
     const effectivePriorInput = priorPaymentsInCurrentFyInr !== null && priorPaymentsInCurrentFyInr !== undefined
         ? priorPaymentsInCurrentFyInr
         : priorFyCategoryPayments;
-    const prior = Math.max(0, Number(effectivePriorInput) || 0);
+    const prior = Math.max(0, cleanNumericAmount(effectivePriorInput));
     const cumulative = prior + totalTransactionGmv;
 
     // Temporal Resolution: "Credit or Payment, whichever is earlier"
@@ -3630,7 +3883,7 @@ export function evaluateSection194O({
  * - Dual-Act 2025: Section 393(1) Table 4 Item (q).
  */
 export function evaluateSection194IA({
-    contractualConsiderationInr = 0,
+    contractualConsiderationInr,
     stampDutyValueInr = null,
     incidentalChargesInr = 0,
     isAgriculturalLand = false,
@@ -3643,9 +3896,11 @@ export function evaluateSection194IA({
     creditDate = null,
     paymentDate = null
 } = {}) {
+    const rawBaseConsideration = Math.max(0, assertMandatoryNumeric(contractualConsiderationInr, 'contractualConsiderationInr', 'evaluateSection194IA'));
+
     // Exclusion 1: Agricultural Land
     if (isAgriculturalLand) {
-        const grossAmount = roundToPaisa(Math.max(0, Number(contractualConsiderationInr) || 0) + Math.max(0, Number(incidentalChargesInr) || 0));
+        const grossAmount = roundToPaisa(rawBaseConsideration + Math.max(0, cleanNumericAmount(incidentalChargesInr)));
         return {
             status: 'SUCCESS',
             statutoryDetermination: 'EXEMPT_AGRICULTURAL_LAND',
@@ -3673,12 +3928,11 @@ export function evaluateSection194IA({
         };
     }
 
-    const rawBaseConsideration = Math.max(0, Number(contractualConsiderationInr) || 0);
-    const rawIncidental = Math.max(0, Number(incidentalChargesInr) || 0);
+    const rawIncidental = Math.max(0, cleanNumericAmount(incidentalChargesInr));
     const totalContractualConsideration = roundToPaisa(rawBaseConsideration + rawIncidental);
 
-    const effectiveSdv = (stampDutyValueInr !== null && stampDutyValueInr !== undefined && !isNaN(Number(stampDutyValueInr)))
-        ? roundToPaisa(Math.max(0, Number(stampDutyValueInr)))
+    const effectiveSdv = (stampDutyValueInr !== null && stampDutyValueInr !== undefined)
+        ? roundToPaisa(Math.max(0, cleanNumericAmount(stampDutyValueInr)))
         : totalContractualConsideration;
 
     // Finance Act 2022 Amendment: Higher of consideration or Stamp Duty Value
@@ -3710,7 +3964,7 @@ export function evaluateSection194IA({
 
     const isAct2025 = Boolean(effectiveDate && String(effectiveDate).slice(0, 10) >= '2026-04-01');
     const governingSection = isAct2025
-        ? 'Income-tax Act, 2025 Section 393(1) Table 4 Item (q)'
+        ? 'Income-tax Act, 2025 Section 393(1), Table 1, Sl. No. 3(i)'
         : 'Income-tax Act, 1961 Section 194-IA';
 
     if (!isThresholdMet) {
@@ -3804,7 +4058,7 @@ export function calculateAdvanceTaxAndInterest({
     suddenIncomeExceptions = null,
     assessmentDate = null,
     isAct2025 = null
-}) {
+} = {}) {
     if (estimatedAssessedTaxInr === undefined || estimatedAssessedTaxInr === null) {
         return {
             status: 'INDETERMINATE',
@@ -3817,12 +4071,12 @@ export function calculateAdvanceTaxAndInterest({
         };
     }
 
-    const estimatedTax = Number(estimatedAssessedTaxInr);
-    const credits = Number(tdsTcsCreditInr || 0);
-    if (isNaN(estimatedTax) || estimatedTax < 0 || !Number.isFinite(estimatedTax)) {
+    const estimatedTax = cleanNumericAmount(estimatedAssessedTaxInr);
+    const credits = cleanNumericAmount(tdsTcsCreditInr);
+    if (estimatedTax < 0) {
         throw new Error('[@mudraforge/statutory] Invalid estimatedAssessedTaxInr: expected non-negative finite number.');
     }
-    if (isNaN(credits) || credits < 0 || !Number.isFinite(credits)) {
+    if (credits < 0) {
         throw new Error('[@mudraforge/statutory] Invalid tdsTcsCreditInr: expected non-negative finite number.');
     }
 
@@ -3867,10 +4121,10 @@ export function calculateAdvanceTaxAndInterest({
     }
 
     // Cumulative installments calculation (15%, 45%, 75%, 100%)
-    const pQ1 = Math.max(0, Number(paidQ1Inr || 0));
-    const pQ2 = Math.max(0, Number(paidQ2Inr || 0));
-    const pQ3 = Math.max(0, Number(paidQ3Inr || 0));
-    const pQ4 = Math.max(0, Number(paidQ4Inr || 0));
+    const pQ1 = Math.max(0, cleanNumericAmount(paidQ1Inr));
+    const pQ2 = Math.max(0, cleanNumericAmount(paidQ2Inr));
+    const pQ3 = Math.max(0, cleanNumericAmount(paidQ3Inr));
+    const pQ4 = Math.max(0, cleanNumericAmount(paidQ4Inr));
 
     const cumPaidQ1 = pQ1;
     const cumPaidQ2 = cumPaidQ1 + pQ2;
@@ -4079,9 +4333,428 @@ export function calculateAdvanceTaxAndInterest({
  * CGST Rules 2017: Rule 42 (Inputs & Services) & Rule 43 (Capital Goods)
  * ═══════════════════════════════════════════════════════════════════════════
  *
- * Implements monthly common credit isolation (C2), exempt supply ratio (E/F),
- * non-business 5% apportionment (D2), eligible common credit (C3),
- * 60-month capital goods depreciation apportionment (Te), and annual true-up.
+ * Implements deterministic apportionment, monthly provisional reversals (Table 4(B)(1)),
+ * annual true-up reconciliations before 30th November (Notification No. 18/2022-CT),
+ * Section 50(1) 18% statutory interest on shortfalls, Table 4(D)(1) reclaim mechanics,
+ * and 60-month capital goods asset amortisation and conversions.
+ */
+
+/**
+ * GST RULE 42: INPUTS & INPUT SERVICES COMMON ITC REVERSAL CALCULATOR
+ * CGST Act, 2017: Section 17(1) & 17(2) read with Rule 42
+ *
+ * Segregates total input tax (T) into:
+ * - Specific ineligibles: T1 (non-business), T2 (exempt), T3 (blocked u/s 17(5))
+ * - Credited to Electronic Credit Ledger: C1 = T - (T1 + T2 + T3)
+ * - Specific eligible: T4 (taxable & zero-rated supplies)
+ * - Common Credit: C2 = C1 - T4
+ * - Monthly Ineligible Reversals: D1 = (E / F) * C2, D2 = 5% of C2 (non-business)
+ * - Eligible Common Credit: C3 = C2 - (D1 + D2)
+ * - Net Eligible Inputs Credit: G = T4 + C3 = C1 - (D1 + D2)
+ */
+export function calculateRule42InputServiceReversal({
+    taxPeriod = 'CURRENT_PERIOD',
+    totalItcInr,
+    t1NonBusinessInr = 0,
+    t2ExemptInr = 0,
+    t3BlockedInr = 0,
+    t4TaxableInr = 0,
+    exemptTurnoverInr = 0,
+    totalTurnoverInr = 0,
+    hasNonBusinessUse = true,
+    precedingExemptTurnoverInr = 0,
+    precedingTotalTurnoverInr = 0
+} = {}) {
+    if (totalItcInr === undefined || totalItcInr === null) {
+        throw new Error('[@mudraforge/statutory] calculateRule42InputServiceReversal: totalItcInr is required.');
+    }
+
+    const T = roundToPaisa(Math.max(0, cleanNumericAmount(totalItcInr)));
+    const T1 = roundToPaisa(Math.max(0, cleanNumericAmount(t1NonBusinessInr)));
+    const T2 = roundToPaisa(Math.max(0, cleanNumericAmount(t2ExemptInr)));
+    const T3 = roundToPaisa(Math.max(0, cleanNumericAmount(t3BlockedInr)));
+    const T4 = roundToPaisa(Math.max(0, cleanNumericAmount(t4TaxableInr)));
+    const E = Math.max(0, cleanNumericAmount(exemptTurnoverInr));
+    const F = Math.max(0, cleanNumericAmount(totalTurnoverInr));
+
+    const directIneligible = roundToPaisa(T1 + T2 + T3);
+    if (directIneligible > T) {
+        throw new Error(`[@mudraforge/statutory] Sum of direct ineligible credits (T1 + T2 + T3 = ₹${directIneligible}) cannot exceed total ITC (T = ₹${T}).`);
+    }
+
+    // Step 2: C1 - Amount credited to Electronic Credit Ledger
+    const C1 = roundToPaisa(T - directIneligible);
+
+    // Step 3: T4 check
+    if (T4 > C1) {
+        throw new Error(`[@mudraforge/statutory] Exclusive taxable credit T4 (₹${T4}) cannot exceed available credit C1 (₹${C1}).`);
+    }
+
+    // Step 4: C2 - Common Input Credit
+    const C2 = roundToPaisa(C1 - T4);
+
+    // Step 5: Turnover Apportionment (E / F)
+    let exemptRatio = 0;
+    let turnoverBasis = 'CURRENT_TAX_PERIOD';
+
+    if (C2 > 0) {
+        if (F > 0) {
+            exemptRatio = Math.min(1.0, E / F);
+        } else if (E === 0 && F === 0) {
+            const precE = Math.max(0, cleanNumericAmount(precedingExemptTurnoverInr));
+            const precF = Math.max(0, cleanNumericAmount(precedingTotalTurnoverInr));
+            if (precF > 0) {
+                exemptRatio = Math.min(1.0, precE / precF);
+                turnoverBasis = 'PRECEDING_TAX_PERIOD_PROVISO';
+            } else {
+                exemptRatio = 0;
+                turnoverBasis = 'ZERO_TURNOVER_NO_REVERSAL';
+            }
+        } else {
+            // E > 0 but F <= 0 (defensive full exempt cap)
+            exemptRatio = 1.0;
+            turnoverBasis = 'DEFENSIVE_FULL_EXEMPT_CAP';
+        }
+    }
+
+    const D1 = C2 > 0 ? roundToPaisa(C2 * exemptRatio) : 0;
+    const D2 = (C2 > 0 && hasNonBusinessUse) ? roundToPaisa(C2 * 0.05) : 0;
+    const rule42Reversal = roundToPaisa(D1 + D2);
+    const C3 = roundToPaisa(Math.max(0, C2 - rule42Reversal));
+    const netEligibleInputsItc = roundToPaisa(T4 + C3);
+
+    return {
+        status: 'SUCCESS',
+        statutoryDetermination: 'RULE_42_APPORTIONMENT_CALCULATED',
+        governingRules: 'Central Goods and Services Tax Rules, 2017: Rule 42 (Inputs and Input Services)',
+        taxPeriod,
+        totalItcT: T,
+        directIneligibleCredits: {
+            exclusiveNonBusinessT1: T1,
+            exclusiveExemptT2: T2,
+            blockedSection17_5_T3: T3,
+            sumIneligible: directIneligible
+        },
+        creditedToElectronicCreditLedgerC1: C1,
+        exclusiveTaxableT4: T4,
+        commonCreditC2: C2,
+        exemptTurnoverE: E,
+        totalTurnoverF: F,
+        turnoverRatioE_F: Number(exemptRatio.toFixed(6)),
+        turnoverBasis,
+        reversals: {
+            ineligibleExemptCommonD1: D1,
+            nonBusinessCommonD2: D2,
+            totalRule42Reversal: rule42Reversal
+        },
+        eligibleCommonCreditC3: C3,
+        netEligibleInputsItc,
+        gstr3bReporting: {
+            table4A5GrossIngestion: T,
+            table4B1PermanentReversal: roundToPaisa(directIneligible + rule42Reversal),
+            table4B1Rule42OnlyReversal: rule42Reversal,
+            table4CNetItcAvailable: netEligibleInputsItc
+        },
+        isAuthorizedToDisburse: false,
+        statutoryRationale: `Rule 42 credited ₹${C1.toLocaleString('en-IN')} to ledger (after deducting ₹${directIneligible.toLocaleString('en-IN')} direct ineligible). Identified ₹${C2.toLocaleString('en-IN')} common credit, requiring ₹${rule42Reversal.toLocaleString('en-IN')} reversal (D1 exempt: ₹${D1}, D2 non-business: ₹${D2}). Net eligible credit: ₹${netEligibleInputsItc.toLocaleString('en-IN')}. Permanent reversal must be reported in GSTR-3B Table 4(B)(1).`
+    };
+}
+
+/**
+ * GST RULE 42(2): ANNUAL COMMON CREDIT TRUE-UP & RECONCILIATION ENGINE
+ * CGST Rules, 2017: Rule 42(2) read with Section 16(4) and Section 50(1)
+ * Amended by Finance Act, 2022 & Notification No. 18/2022-Central Tax w.e.f. 01.10.2022
+ *
+ * Annual Cutoff: 30th November following the end of the financial year.
+ * - Shortfall Reversal: Payable with 18% p.a. interest under Section 50(1) from 1st April of succeeding FY.
+ * - Excess Reversal: Reclaimable as credit in Form GSTR-3B Table 4(A)(5) and Table 4(D)(1) before 30th November.
+ */
+export function reconcileRule42AnnualTrueUp({
+    financialYear = '2024-25',
+    annualCommonCreditC2Inr,
+    annualExemptTurnoverInr = 0,
+    annualTotalTurnoverInr = 0,
+    cumulativeMonthlyReversalsInr,
+    trueUpExecutionDate = null,
+    hasNonBusinessUse = true,
+    annualInterestRatePercent = 18.0,
+    isRealEstateProject = false
+} = {}) {
+    if (annualCommonCreditC2Inr === undefined || annualCommonCreditC2Inr === null) {
+        throw new Error('[@mudraforge/statutory] reconcileRule42AnnualTrueUp: annualCommonCreditC2Inr is required.');
+    }
+    if (cumulativeMonthlyReversalsInr === undefined || cumulativeMonthlyReversalsInr === null) {
+        throw new Error('[@mudraforge/statutory] reconcileRule42AnnualTrueUp: cumulativeMonthlyReversalsInr is required.');
+    }
+
+    const C2 = roundToPaisa(Math.max(0, cleanNumericAmount(annualCommonCreditC2Inr)));
+    const priorReversals = roundToPaisa(Math.max(0, cleanNumericAmount(cumulativeMonthlyReversalsInr)));
+    const annualE = Math.max(0, cleanNumericAmount(annualExemptTurnoverInr));
+    const annualF = Math.max(0, cleanNumericAmount(annualTotalTurnoverInr));
+
+    // Derive succeeding FY start date & statutory cutoff (30th November)
+    let endYear = 2025;
+    const fyMatch = String(financialYear).match(/^(\d{4})-(\d{2,4})$/);
+    if (fyMatch) {
+        const y1 = parseInt(fyMatch[1], 10);
+        endYear = y1 + 1;
+    }
+    const succeedingFyStartDate = `${endYear}-04-01`;
+    const statutoryCutoffDate = `${endYear}-11-30`;
+
+    const execDateIso = trueUpExecutionDate ? String(trueUpExecutionDate).slice(0, 10) : statutoryCutoffDate;
+    const isFiledBeforeCutoff = execDateIso <= statutoryCutoffDate;
+
+    const annualRatio = annualF > 0 ? Math.min(1.0, annualE / annualF) : 0;
+    const finalAnnualD1 = roundToPaisa(C2 * annualRatio);
+    const finalAnnualD2 = hasNonBusinessUse ? roundToPaisa(C2 * 0.05) : 0;
+    const finalAnnualReversalTotal = roundToPaisa(finalAnnualD1 + finalAnnualD2);
+
+    const differential = roundToPaisa(finalAnnualReversalTotal - priorReversals);
+
+    let reconciliationOutcome = 'BALANCED_ZERO_VARIANCE';
+    let shortfallAmountInr = 0;
+    let excessReversedInr = 0;
+    let interestPayableInr = 0;
+    let daysElapsed = 0;
+    let statutoryAction = 'Annual true-up precisely matches cumulative monthly reversals. No adjustment required.';
+
+    if (differential > 0) {
+        reconciliationOutcome = 'SHORT_REVERSAL_PAYMENT_DUE';
+        shortfallAmountInr = differential;
+        
+        // Interest under Section 50(1) from 1st April of succeeding FY
+        const dStart = new Date(succeedingFyStartDate + 'T00:00:00.000Z').getTime();
+        const dExec = new Date(execDateIso + 'T00:00:00.000Z').getTime();
+        daysElapsed = Math.max(0, Math.floor((dExec - dStart) / (1000 * 60 * 60 * 24)));
+        const rateFrac = (Number(annualInterestRatePercent) || 18.0) / 100;
+        interestPayableInr = roundToPaisa(shortfallAmountInr * rateFrac * (daysElapsed / 365));
+
+        statutoryAction = `Shortfall of ₹${shortfallAmountInr.toLocaleString('en-IN')} must be added to output tax liability / reversed in GSTR-3B Table 4(B)(1) on or before ${statutoryCutoffDate} along with ₹${interestPayableInr.toLocaleString('en-IN')} interest under Section 50(1) (${daysElapsed} days @ ${annualInterestRatePercent}% p.a.).`;
+    } else if (differential < 0) {
+        reconciliationOutcome = 'EXCESS_REVERSAL_RECLAIM_PERMITTED';
+        excessReversedInr = roundToPaisa(Math.abs(differential));
+        statutoryAction = `Excess reversal of ₹${excessReversedInr.toLocaleString('en-IN')} may be reclaimed as eligible ITC in Form GSTR-3B Table 4(A)(5) and reported in Table 4(D)(1) on or before ${statutoryCutoffDate}.`;
+    }
+
+    return {
+        status: 'SUCCESS',
+        statutoryDetermination: 'ANNUAL_TRUE_UP_RECONCILED',
+        governingRules: 'Central Goods and Services Tax Rules, 2017: Rule 42(2) & Finance Act, 2022',
+        financialYear,
+        statutoryCutoffDate,
+        succeedingFyStartDate,
+        trueUpExecutionDate: execDateIso,
+        isFiledBeforeCutoff,
+        annualCommonCreditC2Inr: C2,
+        annualExemptTurnoverInr: annualE,
+        annualTotalTurnoverInr: annualF,
+        annualExemptRatio: Number(annualRatio.toFixed(6)),
+        finalAnnualReversals: {
+            finalAnnualD1ExemptInr: finalAnnualD1,
+            finalAnnualD2NonBusinessInr: finalAnnualD2,
+            finalAnnualRequiredTotalInr: finalAnnualReversalTotal
+        },
+        cumulativeMonthlyReversalsMadeInr: priorReversals,
+        differentialAdjustmentInr: differential,
+        reconciliationOutcome,
+        shortfallAmountInr,
+        excessReversedInr,
+        interestAssessment: {
+            interestRatePercent: annualInterestRatePercent,
+            interestCommencementDate: succeedingFyStartDate,
+            interestEndDate: execDateIso,
+            daysElapsed,
+            interestPayableInr
+        },
+        isRealEstateProject: !!isRealEstateProject,
+        statutoryAction,
+        isAuthorizedToDisburse: false,
+        statutoryRationale: `Annual common credit ₹${C2.toLocaleString('en-IN')} with annual exempt ratio ${annualRatio.toFixed(4)} requires aggregate annual reversal of ₹${finalAnnualReversalTotal.toLocaleString('en-IN')}. Cumulative monthly reversals made: ₹${priorReversals.toLocaleString('en-IN')}. Outcome: ${reconciliationOutcome} (${differential > 0 ? `Shortfall ₹${shortfallAmountInr} + Sec 50(1) Interest ₹${interestPayableInr}` : (differential < 0 ? `Reclaimable ₹${excessReversedInr}` : 'Zero Variance')}).`
+    };
+}
+
+/**
+ * GST RULE 43: CAPITAL GOODS COMMON ITC AMORTISATION & REVERSAL CALCULATOR
+ * CGST Act, 2017: Section 17(1) & 17(2) read with Rule 43
+ *
+ * Implements:
+ * - 60-month statutory useful life tracking for each capital asset.
+ * - Monthly credit slice: Tm = Tc / 60.
+ * - Aggregate monthly common credit: Tr = sum(Tm).
+ * - Monthly exempt reversal: Te = (E / F) * Tr (added to output tax liability in Table 4(B)(1)).
+ * - Asset conversion: 5% reduction per quarter under Rule 43(1)(c) for exclusive-to-common transitions.
+ */
+export function calculateRule43CapitalGoodsReversal({
+    taxPeriod = 'CURRENT_PERIOD',
+    taxPeriodDate = new Date().toISOString().slice(0, 10),
+    exemptTurnoverInr = 0,
+    totalTurnoverInr = 0,
+    capitalGoodsList = [],
+    precedingExemptTurnoverInr = 0,
+    precedingTotalTurnoverInr = 0
+} = {}) {
+    if (!Array.isArray(capitalGoodsList)) {
+        throw new Error('[@mudraforge/statutory] calculateRule43CapitalGoodsReversal: capitalGoodsList must be an array.');
+    }
+
+    const E = Math.max(0, cleanNumericAmount(exemptTurnoverInr));
+    const F = Math.max(0, cleanNumericAmount(totalTurnoverInr));
+
+    let exemptRatio = 0;
+    let turnoverBasis = 'CURRENT_TAX_PERIOD';
+
+    if (F > 0) {
+        exemptRatio = Math.min(1.0, E / F);
+    } else if (E === 0 && F === 0) {
+        const precE = Math.max(0, cleanNumericAmount(precedingExemptTurnoverInr));
+        const precF = Math.max(0, cleanNumericAmount(precedingTotalTurnoverInr));
+        if (precF > 0) {
+            exemptRatio = Math.min(1.0, precE / precF);
+            turnoverBasis = 'PRECEDING_TAX_PERIOD_PROVISO';
+        } else {
+            exemptRatio = 0;
+            turnoverBasis = 'ZERO_TURNOVER_NO_REVERSAL';
+        }
+    } else {
+        exemptRatio = 1.0;
+        turnoverBasis = 'DEFENSIVE_FULL_EXEMPT_CAP';
+    }
+
+    const DEEMED_USEFUL_LIFE_MONTHS = 60;
+    const calcDate = new Date(String(taxPeriodDate).slice(0, 10) + 'T00:00:00.000Z');
+
+    let totalCommonTc = 0;
+    let totalMonthlySliceTr = 0;
+    const assetSchedules = [];
+
+    for (const asset of capitalGoodsList) {
+        const assetId = asset.assetId || 'ASSET-UNKNOWN';
+        const description = asset.description || 'Capital Good';
+        const rawItc = roundToPaisa(Math.max(0, cleanNumericAmount(asset.itcAmountInr || asset.taxAmount)));
+        const category = String(asset.category || asset.useCategory || 'COMMON').toUpperCase();
+        const invoiceDateIso = asset.invoiceDate ? String(asset.invoiceDate).slice(0, 10) : taxPeriodDate;
+
+        if (category === 'EXEMPT_ONLY') {
+            assetSchedules.push({
+                assetId,
+                description,
+                category,
+                invoiceDate: invoiceDateIso,
+                originalItcInr: rawItc,
+                effectiveCommonCreditInr: 0,
+                monthlyCreditTmInr: 0,
+                monthlyReversalTeInr: 0,
+                status: 'EXEMPT_EXCLUDED_FROM_LEDGER',
+                statutoryNote: 'Under Rule 43(1)(a), capital goods used exclusively for exempt supplies are not credited to Electronic Credit Ledger.'
+            });
+            continue;
+        }
+
+        if (category === 'TAXABLE_ONLY') {
+            assetSchedules.push({
+                assetId,
+                description,
+                category,
+                invoiceDate: invoiceDateIso,
+                originalItcInr: rawItc,
+                effectiveCommonCreditInr: 0,
+                monthlyCreditTmInr: 0,
+                monthlyReversalTeInr: 0,
+                status: 'TAXABLE_FULL_CREDIT_NO_REVERSAL',
+                statutoryNote: 'Under Rule 43(1)(b), capital goods used exclusively for taxable supplies are credited in full with zero monthly reversal.'
+            });
+            continue;
+        }
+
+        // Category is COMMON (or converted to COMMON)
+        let effectiveItc = rawItc;
+        let quartersElapsed = 0;
+        let reductionPercent = 0;
+
+        if (asset.priorCategory === 'EXEMPT_ONLY' && asset.conversionDate) {
+            const convDateIso = String(asset.conversionDate).slice(0, 10);
+            const dInv = new Date(invoiceDateIso + 'T00:00:00.000Z').getTime();
+            const dConv = new Date(convDateIso + 'T00:00:00.000Z').getTime();
+            const daysConv = Math.max(0, Math.floor((dConv - dInv) / (1000 * 60 * 60 * 24)));
+            quartersElapsed = daysConv > 0 ? Math.ceil(daysConv / 91.25) : 0;
+            reductionPercent = Math.min(100, quartersElapsed * 5);
+            effectiveItc = roundToPaisa(rawItc * (1 - reductionPercent / 100));
+        }
+
+        // Calculate months elapsed from invoice date to calculation date
+        const dInv = new Date(invoiceDateIso + 'T00:00:00.000Z');
+        const monthsElapsed = (calcDate.getFullYear() - dInv.getFullYear()) * 12 + (calcDate.getMonth() - dInv.getMonth());
+
+        let monthlyCreditTm = 0;
+        let monthlyReversalTe = 0;
+        let status = 'ACTIVE_IN_COMMON_POOL';
+
+        if (monthsElapsed >= 0 && monthsElapsed < DEEMED_USEFUL_LIFE_MONTHS) {
+            monthlyCreditTm = roundToPaisa(effectiveItc / DEEMED_USEFUL_LIFE_MONTHS);
+            monthlyReversalTe = roundToPaisa(monthlyCreditTm * exemptRatio);
+            totalCommonTc = roundToPaisa(totalCommonTc + effectiveItc);
+            totalMonthlySliceTr = roundToPaisa(totalMonthlySliceTr + monthlyCreditTm);
+        } else if (monthsElapsed >= DEEMED_USEFUL_LIFE_MONTHS) {
+            status = 'EXPIRED_USEFUL_LIFE_60_MONTHS';
+        } else {
+            status = 'PRE_ACQUISITION_PERIOD';
+        }
+
+        assetSchedules.push({
+            assetId,
+            description,
+            category: 'COMMON',
+            invoiceDate: invoiceDateIso,
+            originalItcInr: rawItc,
+            effectiveCommonCreditInr: effectiveItc,
+            reductionFactorAppliedPercent: reductionPercent,
+            monthsElapsed,
+            remainingUsefulLifeMonths: Math.max(0, DEEMED_USEFUL_LIFE_MONTHS - Math.max(0, monthsElapsed)),
+            monthlyCreditTmInr: monthlyCreditTm,
+            monthlyReversalTeInr: monthlyReversalTe,
+            status,
+            statutoryNote: status === 'ACTIVE_IN_COMMON_POOL'
+                ? `Active in common pool (Month ${monthsElapsed + 1}/60). Tm = ₹${monthlyCreditTm}, Te reversal = ₹${monthlyReversalTe}.`
+                : (status === 'EXPIRED_USEFUL_LIFE_60_MONTHS' ? 'Deemed useful life of 60 months has expired. No further reversal required.' : 'Asset acquired after tax period.')
+        });
+    }
+
+    const totalPeriodReversalTe = roundToPaisa(totalMonthlySliceTr * exemptRatio);
+    const netEligibleMonthlyCapitalItc = roundToPaisa(Math.max(0, totalMonthlySliceTr - totalPeriodReversalTe));
+
+    return {
+        status: 'SUCCESS',
+        statutoryDetermination: 'RULE_43_CAPITAL_GOODS_APPORTIONED',
+        governingRules: 'Central Goods and Services Tax Rules, 2017: Rule 43 (Capital Goods)',
+        taxPeriod,
+        taxPeriodDate: String(taxPeriodDate).slice(0, 10),
+        exemptTurnoverE: E,
+        totalTurnoverF: F,
+        turnoverRatioE_F: Number(exemptRatio.toFixed(6)),
+        turnoverBasis,
+        deemedUsefulLifeMonths: DEEMED_USEFUL_LIFE_MONTHS,
+        summary: {
+            totalAssetsAssessed: capitalGoodsList.length,
+            activeCommonAssetsCount: assetSchedules.filter(a => a.status === 'ACTIVE_IN_COMMON_POOL').length,
+            totalCommonCreditTcInr: totalCommonTc,
+            monthlyCommonCreditSliceTrInr: totalMonthlySliceTr,
+            monthlyReversalTeInr: totalPeriodReversalTe,
+            netEligibleMonthlyCapitalItcInr: netEligibleMonthlyCapitalItc
+        },
+        gstr3bReporting: {
+            reportingTable: 'Table 4(B)(1) (Permanent Reversals)',
+            monthlyReversalAmountInr: totalPeriodReversalTe
+        },
+        assetSchedules,
+        isAuthorizedToDisburse: false,
+        statutoryRationale: `Assessed ${capitalGoodsList.length} capital goods. Common pool ITC (Tc): ₹${totalCommonTc.toLocaleString('en-IN')}, monthly slice (Tr): ₹${totalMonthlySliceTr.toLocaleString('en-IN')}. Monthly exempt reversal (Te = Tr * E/F): ₹${totalPeriodReversalTe.toLocaleString('en-IN')}. Reversal must be added to output tax liability / reported in Table 4(B)(1).`
+    };
+}
+
+/**
+ * UNIFIED ORCHESTRATOR: GST RULE 42 & 43 COMBINED APPORTIONMENT
+ * Backward-compatible facade coordinating inputs/services, capital goods, and annual true-ups.
  */
 export function calculateGstItcApportionmentRule42_43({
     taxPeriod = null,
@@ -4094,16 +4767,19 @@ export function calculateGstItcApportionmentRule42_43({
     exclusiveTaxableT4 = 0,
     exemptTurnoverE = 0,
     totalTurnoverF = 0,
+    hasNonBusinessUse = true,
     // Rule 43 Inputs (Capital Goods):
     capitalGoodsCommonCreditA = 0,
     capitalGoodsPriorQuartersExempt = 0,
+    capitalGoodsList = null,
     // Annual True-Up Reconciliation parameters:
     isAnnualTrueUp = false,
     annualExemptTurnover = null,
     annualTotalTurnover = null,
     sumOfMonthlyReversalsD1 = 0,
-    isRealEstateProject = false
-}) {
+    isRealEstateProject = false,
+    trueUpExecutionDate = null
+} = {}) {
     if (totalInputTaxCreditT === undefined || totalInputTaxCreditT === null) {
         return {
             status: 'INDETERMINATE',
@@ -4116,121 +4792,101 @@ export function calculateGstItcApportionmentRule42_43({
         };
     }
 
-    const T = Number(totalInputTaxCreditT);
-    const T1 = Math.max(0, Number(exclusiveNonBusinessT1 || 0));
-    const T2 = Math.max(0, Number(exclusiveExemptT2 || 0));
-    const T3 = Math.max(0, Number(blockedSection17_5_T3 || 0));
-    const T4 = Math.max(0, Number(exclusiveTaxableT4 || 0));
-    const E = Math.max(0, Number(exemptTurnoverE || 0));
-    const F = Math.max(0, Number(totalTurnoverF || 0));
-
-    if (isNaN(T) || T < 0 || !Number.isFinite(T)) {
-        throw new Error('[@mudraforge/statutory] Invalid totalInputTaxCreditT: expected non-negative finite number.');
-    }
-
-    // Step 1: Ineligible credits under Rule 42(1)(a)-(c)
-    const ineligibleDirect = roundToPaisa(T1 + T2 + T3);
-    if (ineligibleDirect > T) {
-        throw new Error(`[@mudraforge/statutory] Sum of direct ineligible credits (T1 + T2 + T3 = ₹${ineligibleDirect}) cannot exceed total ITC (T = ₹${T}).`);
-    }
-
-    // Step 2: C1 - Amount credited to Electronic Credit Ledger
-    const C1 = roundToPaisa(T - ineligibleDirect);
-
-    // Step 3: T4 - Exclusive taxable supplies
-    if (T4 > C1) {
-        throw new Error(`[@mudraforge/statutory] Exclusive taxable credit T4 (₹${T4}) cannot exceed available credit C1 (₹${C1}).`);
-    }
-
-    // Step 4: C2 - Common Input Credit
-    const C2 = roundToPaisa(C1 - T4);
-
-    // Step 5: D1 - Ineligible common credit attributable to exempt supplies
-    // Formula: D1 = (E / F) * C2
-    let exemptRatio = 0;
-    let D1 = 0;
-    let turnoverBasis = 'TAX_PERIOD_TURNOVER';
-
-    if (C2 > 0) {
-        if (F > 0) {
-            exemptRatio = E / F;
-            if (exemptRatio > 1) exemptRatio = 1; // Defensive cap: exempt cannot exceed total turnover
-            D1 = roundToPaisa(C2 * exemptRatio);
-        } else if (E === 0 && F === 0) {
-            // No turnover in tax period; Rule 42 proviso: use last tax period with turnover
-            turnoverBasis = 'ZERO_TURNOVER_DEFERRED_TO_PRECEDING_PERIOD';
-            exemptRatio = 0;
-            D1 = 0;
-        } else {
-            // E > 0 but F <= 0 (data anomaly)
-            exemptRatio = 1.0;
-            D1 = C2;
-        }
-    }
-
-    // Step 6: D2 - Ineligible common credit attributable to non-business use (5% of C2)
-    const D2 = C2 > 0 ? roundToPaisa(C2 * 0.05) : 0;
-
-    // Step 7: C3 - Eligible common credit
-    // Formula: C3 = C2 - (D1 + D2)
-    const C3 = roundToPaisa(Math.max(0, C2 - (D1 + D2)));
-
-    // Total Rule 42 reversal added to output tax liability:
-    const rule42Reversal = roundToPaisa(D1 + D2);
-
-    // Total net eligible input credit for the period (exclusive taxable T4 + eligible common C3):
-    const netEligibleInputsItc = roundToPaisa(T4 + C3);
-
-    // ═══════════════════════════════════════════════════════════════════════
-    // RULE 43: CAPITAL GOODS APPORTIONMENT
-    // ═══════════════════════════════════════════════════════════════════════
-    const rawA = Math.max(0, Number(capitalGoodsCommonCreditA || 0));
-    const priorQ = Math.max(0, Number(capitalGoodsPriorQuartersExempt || 0));
-    
-    // If capital goods were used exclusively for exempt/non-business and converted to common,
-    // reduce credit by 5% per quarter of prior usage
-    const reductionFactor = Math.min(1.0, priorQ * 0.05);
-    const effectiveA = roundToPaisa(rawA * (1 - reductionFactor));
+    // Step 1: Rule 42 Inputs & Input Services Evaluation
+    const rule42Result = calculateRule42InputServiceReversal({
+        taxPeriod: taxPeriod || 'CURRENT_MONTH',
+        totalItcInr: totalInputTaxCreditT,
+        t1NonBusinessInr: exclusiveNonBusinessT1,
+        t2ExemptInr: exclusiveExemptT2,
+        t3BlockedInr: blockedSection17_5_T3,
+        t4TaxableInr: exclusiveTaxableT4,
+        exemptTurnoverInr: exemptTurnoverE,
+        totalTurnoverInr: totalTurnoverF,
+        hasNonBusinessUse
+    });
 
-    // Deemed useful life: 60 months (5 years)
+    // Step 2: Rule 43 Capital Goods Evaluation
+    let capitalGoodsBreakdown = null;
+    let capitalGoodsReversalTe = 0;
+    let monthlyCapitalGoodsCreditTm = 0;
     const DEEMED_USEFUL_LIFE_MONTHS = 60;
-    const monthlyCapitalGoodsCreditTm = rawA > 0 ? roundToPaisa(effectiveA / DEEMED_USEFUL_LIFE_MONTHS) : 0;
 
-    // Capital goods reversal for the month: Te = (E / F) * Tr
-    let capitalGoodsReversalTe = 0;
-    if (monthlyCapitalGoodsCreditTm > 0 && F > 0) {
-        capitalGoodsReversalTe = roundToPaisa(monthlyCapitalGoodsCreditTm * exemptRatio);
+    if (Array.isArray(capitalGoodsList) && capitalGoodsList.length > 0) {
+        const rule43Result = calculateRule43CapitalGoodsReversal({
+            taxPeriod: taxPeriod || 'CURRENT_MONTH',
+            exemptTurnoverInr: exemptTurnoverE,
+            totalTurnoverInr: totalTurnoverF,
+            capitalGoodsList
+        });
+        capitalGoodsReversalTe = rule43Result.summary.monthlyReversalTeInr;
+        monthlyCapitalGoodsCreditTm = rule43Result.summary.monthlyCommonCreditSliceTrInr;
+        capitalGoodsBreakdown = {
+            capitalGoodsCommonCreditA: rule43Result.summary.totalCommonCreditTcInr,
+            deemedUsefulLifeMonths: DEEMED_USEFUL_LIFE_MONTHS,
+            priorQuartersExempt: 0,
+            reductionFactorAppliedPercent: 0,
+            effectiveCommonCredit: rule43Result.summary.totalCommonCreditTcInr,
+            monthlyCreditTm: monthlyCapitalGoodsCreditTm,
+            monthlyReversalTe: capitalGoodsReversalTe,
+            eligibleCapitalGoodsCreditMonthly: rule43Result.summary.netEligibleMonthlyCapitalItcInr,
+            assetSchedules: rule43Result.assetSchedules
+        };
+    } else {
+        const rawA = Math.max(0, Number(capitalGoodsCommonCreditA || 0));
+        const priorQ = Math.max(0, Number(capitalGoodsPriorQuartersExempt || 0));
+        const reductionFactor = Math.min(1.0, priorQ * 0.05);
+        const effectiveA = roundToPaisa(rawA * (1 - reductionFactor));
+        monthlyCapitalGoodsCreditTm = rawA > 0 ? roundToPaisa(effectiveA / DEEMED_USEFUL_LIFE_MONTHS) : 0;
+        capitalGoodsReversalTe = monthlyCapitalGoodsCreditTm > 0 && Number(totalTurnoverF) > 0
+            ? roundToPaisa(monthlyCapitalGoodsCreditTm * rule42Result.turnoverRatioE_F)
+            : 0;
+
+        capitalGoodsBreakdown = {
+            capitalGoodsCommonCreditA: rawA,
+            deemedUsefulLifeMonths: DEEMED_USEFUL_LIFE_MONTHS,
+            priorQuartersExempt: priorQ,
+            reductionFactorAppliedPercent: reductionFactor * 100,
+            effectiveCommonCredit: effectiveA,
+            monthlyCreditTm: monthlyCapitalGoodsCreditTm,
+            monthlyReversalTe: capitalGoodsReversalTe,
+            eligibleCapitalGoodsCreditMonthly: Math.max(0, monthlyCapitalGoodsCreditTm - capitalGoodsReversalTe)
+        };
     }
 
-    const totalPeriodReversal = roundToPaisa(rule42Reversal + capitalGoodsReversalTe);
-    const totalNetEligibleItc = roundToPaisa(netEligibleInputsItc + Math.max(0, monthlyCapitalGoodsCreditTm - capitalGoodsReversalTe));
+    const totalPeriodReversal = roundToPaisa(rule42Result.reversals.totalRule42Reversal + capitalGoodsReversalTe);
+    const totalNetEligibleItc = roundToPaisa(rule42Result.netEligibleInputsItc + Math.max(0, monthlyCapitalGoodsCreditTm - capitalGoodsReversalTe));
 
-    // ═══════════════════════════════════════════════════════════════════════
-    // ANNUAL TRUE-UP RECONCILIATION (RULE 42(2) & 43(2))
-    // ═══════════════════════════════════════════════════════════════════════
+    // Step 3: Annual True-Up Reconciliation (Rule 42(2) & 43(2))
     let annualTrueUpDetails = null;
     if (isAnnualTrueUp && annualTotalTurnover !== null && annualExemptTurnover !== null) {
-        const annualE = Math.max(0, Number(annualExemptTurnover || 0));
-        const annualF = Math.max(0, Number(annualTotalTurnover || 0));
-        const annualRatio = annualF > 0 ? (annualE / annualF) : 0;
-        
-        // Final annual D1 calculated on cumulative common credit C2
-        const annualD1Final = roundToPaisa(C2 * annualRatio);
-        const priorD1Claimed = Math.max(0, Number(sumOfMonthlyReversalsD1 || 0));
-        const trueUpDifference = roundToPaisa(annualD1Final - priorD1Claimed);
+        const trueUpResult = reconcileRule42AnnualTrueUp({
+            financialYear,
+            annualCommonCreditC2Inr: rule42Result.commonCreditC2,
+            annualExemptTurnoverInr: annualExemptTurnover,
+            annualTotalTurnoverInr: annualTotalTurnover,
+            cumulativeMonthlyReversalsInr: sumOfMonthlyReversalsD1,
+            trueUpExecutionDate,
+            hasNonBusinessUse,
+            isRealEstateProject
+        });
 
         annualTrueUpDetails = {
             isAnnualTrueUp: true,
             financialYear,
-            annualExemptTurnover: annualE,
-            annualTotalTurnover: annualF,
-            annualExemptRatio: Number(annualRatio.toFixed(6)),
-            finalAnnualD1Inr: annualD1Final,
-            sumOfMonthlyD1ReversalsClaimedInr: priorD1Claimed,
-            differentialAdjustmentInr: trueUpDifference,
-            adjustmentAction: trueUpDifference > 0 
-                ? 'ADD_TO_OUTPUT_LIABILITY_WITH_SECTION_50_INTEREST' 
-                : (trueUpDifference < 0 ? 'RECLAIM_AS_ELIGIBLE_ITC' : 'ZERO_DIFFERENTIAL_MATCHED'),
+            annualExemptTurnover: trueUpResult.annualExemptTurnoverInr,
+            annualTotalTurnover: trueUpResult.annualTotalTurnoverInr,
+            annualExemptRatio: trueUpResult.annualExemptRatio,
+            finalAnnualD1Inr: trueUpResult.finalAnnualReversals.finalAnnualD1ExemptInr,
+            sumOfMonthlyD1ReversalsClaimedInr: trueUpResult.cumulativeMonthlyReversalsMadeInr,
+            differentialAdjustmentInr: trueUpResult.differentialAdjustmentInr,
+            adjustmentAction: trueUpResult.reconciliationOutcome === 'SHORT_REVERSAL_PAYMENT_DUE'
+                ? 'ADD_TO_OUTPUT_LIABILITY_WITH_SECTION_50_INTEREST'
+                : (trueUpResult.reconciliationOutcome === 'EXCESS_REVERSAL_RECLAIM_PERMITTED' ? 'RECLAIM_AS_ELIGIBLE_ITC' : 'ZERO_DIFFERENTIAL_MATCHED'),
+            reconciliationOutcome: trueUpResult.reconciliationOutcome,
+            shortfallAmountInr: trueUpResult.shortfallAmountInr,
+            excessReversedInr: trueUpResult.excessReversedInr,
+            interestAssessment: trueUpResult.interestAssessment,
+            statutoryAction: trueUpResult.statutoryAction,
             statutoryFilingDeadlineNotice: isRealEstateProject
                 ? 'Real estate project true-up governed by Annexure I/II of Notification 16/2019-CT.'
                 : 'Annual adjustment due on or before filing return for month of September following FY end (or 30th November cutoff).'
@@ -4244,48 +4900,39 @@ export function calculateGstItcApportionmentRule42_43({
         taxPeriod: taxPeriod || 'CURRENT_MONTH',
         financialYear,
         rule42InputsBreakdown: {
-            totalItcT: T,
+            totalItcT: rule42Result.totalItcT,
             directIneligible: {
-                exclusiveNonBusinessT1: T1,
-                exclusiveExemptT2: T2,
-                blockedSection17_5_T3: T3,
-                sumIneligible: ineligibleDirect
+                exclusiveNonBusinessT1: rule42Result.directIneligibleCredits.exclusiveNonBusinessT1,
+                exclusiveExemptT2: rule42Result.directIneligibleCredits.exclusiveExemptT2,
+                blockedSection17_5_T3: rule42Result.directIneligibleCredits.blockedSection17_5_T3,
+                sumIneligible: rule42Result.directIneligibleCredits.sumIneligible
             },
-            creditedToElectronicLedgerC1: C1,
-            exclusiveTaxableT4: T4,
-            commonCreditC2: C2,
-            exemptTurnoverE: E,
-            totalTurnoverF: F,
-            exemptRatio: Number(exemptRatio.toFixed(6)),
-            turnoverBasis,
+            creditedToElectronicLedgerC1: rule42Result.creditedToElectronicCreditLedgerC1,
+            exclusiveTaxableT4: rule42Result.exclusiveTaxableT4,
+            commonCreditC2: rule42Result.commonCreditC2,
+            exemptTurnoverE: rule42Result.exemptTurnoverE,
+            totalTurnoverF: rule42Result.totalTurnoverF,
+            exemptRatio: rule42Result.turnoverRatioE_F,
+            turnoverBasis: rule42Result.turnoverBasis,
             reversals: {
-                ineligibleExemptCommonD1: D1,
-                nonBusinessCommonD2: D2,
-                totalRule42Reversal: rule42Reversal
+                ineligibleExemptCommonD1: rule42Result.reversals.ineligibleExemptCommonD1,
+                nonBusinessCommonD2: rule42Result.reversals.nonBusinessCommonD2,
+                totalRule42Reversal: rule42Result.reversals.totalRule42Reversal
             },
-            eligibleCommonCreditC3: C3,
-            netEligibleInputsItc
-        },
-        rule43CapitalGoodsBreakdown: {
-            capitalGoodsCommonCreditA: rawA,
-            deemedUsefulLifeMonths: DEEMED_USEFUL_LIFE_MONTHS,
-            priorQuartersExempt: priorQ,
-            reductionFactorAppliedPercent: reductionFactor * 100,
-            effectiveCommonCredit: effectiveA,
-            monthlyCreditTm: monthlyCapitalGoodsCreditTm,
-            monthlyReversalTe: capitalGoodsReversalTe,
-            eligibleCapitalGoodsCreditMonthly: Math.max(0, monthlyCapitalGoodsCreditTm - capitalGoodsReversalTe)
+            eligibleCommonCreditC3: rule42Result.eligibleCommonCreditC3,
+            netEligibleInputsItc: rule42Result.netEligibleInputsItc
         },
+        rule43CapitalGoodsBreakdown: capitalGoodsBreakdown,
         summary: {
-            totalGrossItcT: T,
-            totalDirectIneligible: ineligibleDirect,
-            totalCommonCreditApportioned: C2,
+            totalGrossItcT: rule42Result.totalItcT,
+            totalDirectIneligible: rule42Result.directIneligibleCredits.sumIneligible,
+            totalCommonCreditApportioned: rule42Result.commonCreditC2,
             totalMonthlyReversalAddedToOutputLiability: totalPeriodReversal,
             netEligibleItcTotal: totalNetEligibleItc
         },
         annualTrueUp: annualTrueUpDetails,
         isAuthorizedToDisburse: false,
-        statutoryRationale: `Rule 42 credited ₹${C1.toLocaleString('en-IN')} to ledger, identified ₹${C2.toLocaleString('en-IN')} common credit, and calculated ₹${rule42Reversal.toLocaleString('en-IN')} reversal (D1: ₹${D1}, D2: ₹${D2}). Rule 43 capital goods reversal: ₹${capitalGoodsReversalTe.toLocaleString('en-IN')}. Net eligible ITC: ₹${totalNetEligibleItc.toLocaleString('en-IN')}. Reversal must be added to GSTR-3B Table 4(B).`
+        statutoryRationale: `Rule 42 credited ₹${rule42Result.creditedToElectronicCreditLedgerC1.toLocaleString('en-IN')} to ledger, identified ₹${rule42Result.commonCreditC2.toLocaleString('en-IN')} common credit, and calculated ₹${rule42Result.reversals.totalRule42Reversal.toLocaleString('en-IN')} reversal (D1: ₹${rule42Result.reversals.ineligibleExemptCommonD1}, D2: ₹${rule42Result.reversals.nonBusinessCommonD2}). Rule 43 capital goods reversal: ₹${capitalGoodsReversalTe.toLocaleString('en-IN')}. Net eligible ITC: ₹${totalNetEligibleItc.toLocaleString('en-IN')}. Reversal must be added to GSTR-3B Table 4(B).`
     };
 }
 
@@ -4311,9 +4958,9 @@ export function calculateItcReversalRule37({
     isScheduleISupply = false, // Deemed supplies without consideration under Schedule I are exempt
     annualInterestRatePercent = 18.0
 } = {}) {
-    const totalInvoice = Number(invoiceAmount) || 0;
-    const totalItc = Number(taxAmount) || 0;
-    const totalPaid = Math.max(0, Number(paidAmount) || 0);
+    const totalInvoice = cleanNumericAmount(invoiceAmount);
+    const totalItc = cleanNumericAmount(taxAmount);
+    const totalPaid = Math.max(0, cleanNumericAmount(paidAmount));
     const unpaidAmount = roundToPaisa(Math.max(0, totalInvoice - totalPaid));
 
     if (!invoiceDate || !/^\d{4}-\d{2}-\d{2}$/.test(String(invoiceDate).slice(0, 10))) {
@@ -4485,7 +5132,7 @@ export function calculateRule37ASupplierNonFilingReversal({
     calculationDate = new Date().toISOString().slice(0, 10),
     annualInterestRatePercent = 18.0
 } = {}) {
-    const rawItc = Number(itcAmount) || 0;
+    const rawItc = cleanNumericAmount(itcAmount);
     const calcDateIso = String(calculationDate).slice(0, 10);
 
     // Compute November 30 cutoff date for the given financial year
@@ -4582,7 +5229,7 @@ export function generateMsme1AndScheduleThreeAging({
     asOfDate = new Date().toISOString().slice(0, 10),
     halfYearPeriod = null, // 'APRIL_TO_SEPTEMBER' | 'OCTOBER_TO_MARCH'
     payables = []
-}) {
+} = {}) {
     if (!Array.isArray(payables)) {
         throw new Error('[@mudraforge/statutory] Invalid payables: expected an array of payable records.');
     }
@@ -4606,7 +5253,7 @@ export function generateMsme1AndScheduleThreeAging({
     const assessedPayables = [];
 
     for (const item of payables) {
-        const amount = Math.max(0, Number(item.amount || item.invoiceAmount || 0));
+        const amount = Math.max(0, cleanNumericAmount(item.amount || item.invoiceAmount));
         if (amount === 0) continue;
 
         const isUnbilled = item.isUnbilled === true;
@@ -4779,14 +5426,14 @@ export function calculateCorporateTaxMatVsConcessional({
     bookProfitAdjustments = null,
     adjustedBookProfitInr = null,
     optedSection115BAA = null
-}) {
+} = {}) {
     const fy = financialYear || '2025-26';
     const ay = assessmentYear || (fy === '2025-26' ? '2026-27' : '2027-28');
-    const turnover = Number(turnoverPrecedingFyInr) || 0;
-    const npbt = Number(netProfitBeforeTaxInr) || 0;
-    const additions = Number(normalTaxAdditionsInr) || 0;
-    const deductions = Number(normalTaxDeductionsInr) || 0;
-    const priorMatCredit = Number(accumulatedMatCreditInr) || 0;
+    const turnover = cleanNumericAmount(turnoverPrecedingFyInr);
+    const npbt = cleanNumericAmount(netProfitBeforeTaxInr);
+    const additions = cleanNumericAmount(normalTaxAdditionsInr);
+    const deductions = cleanNumericAmount(normalTaxDeductionsInr);
+    const priorMatCredit = cleanNumericAmount(accumulatedMatCreditInr);
 
     // A. Normal Corporate Tax Regime
     const taxableIncomeNormal = Math.max(0, roundToPaisa(npbt + additions - deductions));
@@ -4983,8 +5630,8 @@ export function evaluatePlaceOfSupplyAndLut({
     isIntermediaryService = false,
     hasValidLut = false,
     lutArn = null
-}) {
-    const amount = Number(invoiceAmountInr) || 0;
+} = {}) {
+    const amount = cleanNumericAmount(invoiceAmountInr);
     const rate = Number(gstRate) || 0.18;
     const isTransExport = transactionType === 'EXPORT_SERVICES' || transactionType === 'EXPORT_GOODS' || (recipientCountryCode && recipientCountryCode.toUpperCase() !== 'IN');
 
@@ -5165,9 +5812,9 @@ export function calculateTransferPricingAlp({
     isWholesaleTrading = false,
     comparablesData = [],
     transferPricingMethod = 'TNMM'
-}) {
-    const amount = Number(internationalTransactionAmountInr) || 0;
-    const testedMargin = Number(testedPartyOperatingMarginPercent) || 0;
+} = {}) {
+    const amount = cleanNumericAmount(internationalTransactionAmountInr);
+    const testedMargin = cleanNumericAmount(testedPartyOperatingMarginPercent);
     const tolerancePercent = isWholesaleTrading ? 3.0 : 1.0;
 
     if (!isAssociatedEnterprise) {
@@ -5298,9 +5945,9 @@ export function evaluateSection79LossContinuity({
     shareholdingInLossYear = [],
     shareholdingInSetOffYear = [],
     votingPowerHeldByOriginalShareholdersPercent = null
-}) {
-    const bfLoss = Math.max(0, Number(accumulatedBroughtForwardLossInr) || 0);
-    const unabsDep = Math.max(0, Number(unabsorbedDepreciationInr) || 0);
+} = {}) {
+    const bfLoss = Math.max(0, cleanNumericAmount(accumulatedBroughtForwardLossInr));
+    const unabsDep = Math.max(0, cleanNumericAmount(unabsorbedDepreciationInr));
 
     let continuityPercent = votingPowerHeldByOriginalShareholdersPercent !== null
         ? Number(votingPowerHeldByOriginalShareholdersPercent)
@@ -5580,7 +6227,7 @@ export function revalueForeignExchangeIndAs109({
     asOfDate = null,
     reportingCurrency = 'INR',
     items = []
-}) {
+} = {}) {
     const dAsOf = asOfDate ? new Date(asOfDate) : new Date();
     const asOfIso = !isNaN(dAsOf.getTime()) ? dAsOf.toISOString().split('T')[0] : new Date().toISOString().split('T')[0];
 
@@ -5596,9 +6243,9 @@ export function revalueForeignExchangeIndAs109({
         const desc = item.description || item.itemDescription || 'FX Item';
         const itemType = (item.itemType || 'MONETARY_ASSET').toUpperCase();
         const ccy = item.foreignCurrency || item.currency || 'USD';
-        const fcyAmt = Number(item.foreignAmount || item.amount || 0);
-        const bookRate = Number(item.bookingRate || item.historicalRate || 1);
-        const closeRate = Number(item.closingRate || item.spotRate || bookRate);
+        const fcyAmt = cleanNumericAmount(item.foreignAmount || item.amount);
+        const bookRate = cleanNumericAmount(item.bookingRate || item.historicalRate) || 1;
+        const closeRate = cleanNumericAmount(item.closingRate || item.spotRate) || bookRate;
         const isHedge = item.isDesignatedCashFlowHedge === true;
 
         if (itemType === 'NON_MONETARY') {
@@ -5700,7 +6347,7 @@ export function revalueForeignExchangeIndAs109({
  *    - Always returns isAuthorizedToDisburse: false.
  */
 export function evaluateSection194R({
-    currentBenefitValueInr = 0,
+    currentBenefitValueInr,
     cumulativePriorBenefitsInr = 0,
     payerEntityType = 'COMPANY',
     payerPrecedingFyTurnoverInr = null,
@@ -5713,8 +6360,8 @@ export function evaluateSection194R({
     isSpecifiedPerson206AB = false,
     effectiveDate = null
 } = {}) {
-    const benefitVal = roundToPaisa(Math.max(0, Number(currentBenefitValueInr) || 0));
-    const priorVal = roundToPaisa(Math.max(0, Number(cumulativePriorBenefitsInr) || 0));
+    const benefitVal = roundToPaisa(Math.max(0, assertMandatoryNumeric(currentBenefitValueInr, 'currentBenefitValueInr', 'evaluateSection194R')));
+    const priorVal = roundToPaisa(Math.max(0, cleanNumericAmount(cumulativePriorBenefitsInr)));
     const totalCumulativeVal = roundToPaisa(priorVal + benefitVal);
     const dateStr = effectiveDate ? String(effectiveDate).slice(0, 10) : new Date().toISOString().slice(0, 10);
 
@@ -5739,8 +6386,8 @@ export function evaluateSection194R({
     // Exclusion 2: Individual / HUF Payer Turnover Floor
     const normalizedEntityType = String(payerEntityType || 'COMPANY').toUpperCase();
     if (normalizedEntityType === 'INDIVIDUAL' || normalizedEntityType === 'HUF' || normalizedEntityType === 'INDIVIDUAL_HUF') {
-        const turnover = Number(payerPrecedingFyTurnoverInr) || 0;
-        const profReceipts = Number(payerPrecedingFyProfessionReceiptsInr) || 0;
+        const turnover = cleanNumericAmount(payerPrecedingFyTurnoverInr);
+        const profReceipts = cleanNumericAmount(payerPrecedingFyProfessionReceiptsInr);
         const exceedsBusinessFloor = turnover > 10000000; // > 1 Crore
         const exceedsProfessionFloor = profReceipts > 5000000; // > 50 Lakhs
 
@@ -5866,7 +6513,7 @@ export function evaluateSection194R({
  *    - Always returns isAuthorizedToDisburse: false.
  */
 export function evaluateSection194IB({
-    monthlyRentInr = 0,
+    monthlyRentInr,
     tenancyMonthsInYear = 1,
     lastMonthRentPayableInr = null,
     isPayerTaxAuditCovered = false,
@@ -5874,11 +6521,11 @@ export function evaluateSection194IB({
     isLandlordPanInoperative = false,
     effectiveDate = null
 } = {}) {
-    const monthRent = roundToPaisa(Math.max(0, Number(monthlyRentInr) || 0));
+    const monthRent = roundToPaisa(Math.max(0, assertMandatoryNumeric(monthlyRentInr, 'monthlyRentInr', 'evaluateSection194IB')));
     const months = Math.max(1, Math.min(12, Number(tenancyMonthsInYear) || 1));
     const totalRentForPeriod = roundToPaisa(monthRent * months);
-    const lastMonthRent = lastMonthRentPayableInr !== null && lastMonthRentPayableInr !== undefined && !isNaN(Number(lastMonthRentPayableInr))
-        ? roundToPaisa(Math.max(0, Number(lastMonthRentPayableInr)))
+    const lastMonthRent = lastMonthRentPayableInr !== null && lastMonthRentPayableInr !== undefined
+        ? roundToPaisa(Math.max(0, cleanNumericAmount(lastMonthRentPayableInr)))
         : monthRent;
     const dateStr = effectiveDate ? String(effectiveDate).slice(0, 10) : new Date().toISOString().slice(0, 10);
 
@@ -5990,7 +6637,7 @@ export function evaluateSection194IB({
  *    - Always returns isAuthorizedToDisburse: false.
  */
 export function evaluateSection194M({
-    currentPaymentAmountInr = 0,
+    currentPaymentAmountInr,
     cumulativePriorPaymentsInr = 0,
     isPayerCoveredBy194C_H_J = false,
     hasPan = true,
@@ -5998,8 +6645,8 @@ export function evaluateSection194M({
     isSpecifiedPerson206AB = false,
     effectiveDate = null
 } = {}) {
-    const currentAmt = roundToPaisa(Math.max(0, Number(currentPaymentAmountInr) || 0));
-    const priorAmt = roundToPaisa(Math.max(0, Number(cumulativePriorPaymentsInr) || 0));
+    const currentAmt = roundToPaisa(Math.max(0, assertMandatoryNumeric(currentPaymentAmountInr, 'currentPaymentAmountInr', 'evaluateSection194M')));
+    const priorAmt = roundToPaisa(Math.max(0, cleanNumericAmount(cumulativePriorPaymentsInr)));
     const totalCumulative = roundToPaisa(priorAmt + currentAmt);
     const dateStr = effectiveDate ? String(effectiveDate).slice(0, 10) : new Date().toISOString().slice(0, 10);
 
@@ -6085,6 +6732,1294 @@ export function evaluateSection194M({
     };
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// CORPORATE FINANCE, ACCOUNTING STANDARDS & REPORTING ENGINES
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Ind AS 103 / IFRS 3 / US GAAP ASC 805: Business Combinations & Purchase Price Allocation (PPA) Calculator.
+ *
+ * Implements deterministic PPA accounting under the acquisition method:
+ * 1. Computes total consideration transferred:
+ *    - Upfront cash consideration
+ *    - Fair value of equity shares issued (sharesCount * sharePrice)
+ *    - Fair value of contingent consideration / earnouts (probability-weighted discounted payout)
+ *    - Present value of deferred cash consideration (discounted at discountRate / WACC)
+ *    - Fair value of pre-existing non-controlling equity interest (for step acquisitions)
+ * 2. Identifies and aggregates Net Identifiable Assets acquired:
+ *    - Fair value of tangible assets (PPE, working capital, inventory)
+ *    - Fair value of separately identifiable intangible assets (customer relationships, software, brand, patents, order backlog)
+ *    - Less: Fair value of liabilities assumed (current liabilities, borrowings, contingent liabilities)
+ *    - Less: Net deferred tax liability (DTL) arising on fair value adjustments:
+ *      (fairValueIntangiblesStepUp - taxBaseIntangibles) * taxRate
+ * 3. Incorporates Non-Controlling Interest (NCI):
+ *    - 'PROPORTIONATE_SHARE': nciPercentage * netIdentifiableAssets
+ *    - 'FAIR_VALUE': nciFairValue
+ * 4. Determines Goodwill or Gain on Bargain Purchase (Capital Reserve):
+ *    - Acquisition Basis = Consideration Transferred + NCI
+ *    - If Acquisition Basis > Net Identifiable Assets:
+ *        Goodwill = Acquisition Basis - Net Identifiable Assets (capitalized as indefinite-life intangible, tested under Ind AS 36)
+ *    - If Net Identifiable Assets > Acquisition Basis:
+ *        Bargain Purchase Gain = Net Identifiable Assets - Acquisition Basis (requires reassessment; recognized in OCI and accumulated in Capital Reserve)
+ * 5. Expensing of Transaction Costs:
+ *    - Legal, investment banking, due diligence, valuation fees are expensed immediately in P&L (not capitalized into Goodwill)
+ * 6. Generates balanced double-entry vouchers to exact paisa.
+ * 7. Enforces statutory invariant: isAuthorizedToDisburse: false.
+ */
+export function calculateBusinessCombinationsIndAs103(params = {}) {
+    const acquisitionId = params.acquisitionId || 'ACQ-01';
+    const acquirerName = params.acquirerName || 'Acquiring Enterprise';
+    const acquireeName = params.acquireeName || 'Acquired Business Entity';
+    const acquisitionDate = params.acquisitionDate || new Date().toISOString().split('T')[0];
+
+    // 1. Consideration Transferred
+    const rawCons = params.consideration || {};
+    const cashConsideration = roundToPaisa(cleanNumericAmount(rawCons.upfrontCashInr, { defaultValue: 0 }));
+
+    let equitySharesFairValue = 0;
+    if (rawCons.equitySharesIssued && typeof rawCons.equitySharesIssued === 'object') {
+        const count = cleanNumericAmount(rawCons.equitySharesIssued.count, { defaultValue: 0 });
+        const price = cleanNumericAmount(rawCons.equitySharesIssued.sharePriceInr, { defaultValue: 0 });
+        equitySharesFairValue = roundToPaisa(count * price);
+    } else {
+        equitySharesFairValue = roundToPaisa(cleanNumericAmount(rawCons.equitySharesFairValueInr, { defaultValue: 0 }));
+    }
+
+    const contingentConsideration = roundToPaisa(cleanNumericAmount(rawCons.contingentConsiderationFairValueInr, { defaultValue: 0 }));
+
+    let deferredConsiderationPv = 0;
+    if (rawCons.deferredCashConsideration && typeof rawCons.deferredCashConsideration === 'object') {
+        const amt = cleanNumericAmount(rawCons.deferredCashConsideration.amountInr, { defaultValue: 0 });
+        const r = cleanNumericAmount(rawCons.deferredCashConsideration.discountRate, { defaultValue: 0.10 });
+        const yrs = cleanNumericAmount(rawCons.deferredCashConsideration.payableInYears, { defaultValue: 1 });
+        deferredConsiderationPv = roundToPaisa(amt / Math.pow(1 + r, yrs));
+    } else {
+        deferredConsiderationPv = roundToPaisa(cleanNumericAmount(rawCons.deferredConsiderationPresentValueInr, { defaultValue: 0 }));
+    }
+
+    const preExistingInterest = roundToPaisa(cleanNumericAmount(rawCons.preExistingInterestFairValueInr, { defaultValue: 0 }));
+
+    const totalConsiderationTransferred = roundToPaisa(
+        cashConsideration + equitySharesFairValue + contingentConsideration + deferredConsiderationPv + preExistingInterest
+    );
+
+    // 2. Identifiable Assets Acquired
+    const rawAssets = params.identifiableAssets || {};
+    const tangibleAssets = roundToPaisa(cleanNumericAmount(rawAssets.tangibleAssetsFairValueInr, { defaultValue: 0 }));
+    const identifiableIntangibles = roundToPaisa(cleanNumericAmount(rawAssets.identifiableIntangiblesFairValueInr, { defaultValue: 0 }));
+    const otherAssets = roundToPaisa(cleanNumericAmount(rawAssets.otherAssetsFairValueInr, { defaultValue: 0 }));
+    const totalGrossAssets = roundToPaisa(tangibleAssets + identifiableIntangibles + otherAssets);
+
+    // 3. Liabilities Assumed
+    const rawLiab = params.liabilitiesAssumed || {};
+    const borrowings = roundToPaisa(cleanNumericAmount(rawLiab.borrowingsFairValueInr, { defaultValue: 0 }));
+    const workingCapitalLiab = roundToPaisa(cleanNumericAmount(rawLiab.workingCapitalLiabilitiesInr, { defaultValue: 0 }));
+    const contingentLiab = roundToPaisa(cleanNumericAmount(rawLiab.contingentLiabilitiesRecognizedInr, { defaultValue: 0 }));
+
+    // Deferred Tax on Intangibles Step-Up
+    const taxRate = cleanNumericAmount(params.taxRate, { defaultValue: 0.25168 });
+    const intangiblesTaxBase = cleanNumericAmount(params.intangiblesTaxBaseInr, { defaultValue: 0 });
+    const intangiblesStepUp = Math.max(0, identifiableIntangibles - intangiblesTaxBase);
+    const deferredTaxLiability = roundToPaisa(intangiblesStepUp * taxRate);
+
+    const totalLiabilitiesAssumed = roundToPaisa(borrowings + workingCapitalLiab + contingentLiab + deferredTaxLiability);
+    const netIdentifiableAssets = roundToPaisa(totalGrossAssets - totalLiabilitiesAssumed);
+
+    if (totalConsiderationTransferred <= 0 && netIdentifiableAssets <= 0) {
+        return {
+            status: 'INSUFFICIENT_DATA',
+            standard: 'Ind AS 103 / IFRS 3 / US GAAP ASC 805',
+            acquisitionId,
+            isAuthorizedToDisburse: false,
+            statutoryRationale: 'Consideration transferred or identifiable net assets must be greater than zero.'
+        };
+    }
+
+    // 4. Non-Controlling Interest (NCI)
+    const rawNci = params.nonControllingInterest || {};
+    const nciMethod = String(rawNci.method || 'PROPORTIONATE_SHARE').toUpperCase();
+    const nciPct = cleanNumericAmount(rawNci.percentage, { defaultValue: 0 });
+    let nciAmount = 0;
+    if (nciMethod === 'FAIR_VALUE' && rawNci.fairValueInr) {
+        nciAmount = roundToPaisa(cleanNumericAmount(rawNci.fairValueInr, { defaultValue: 0 }));
+    } else {
+        nciAmount = roundToPaisa(Math.max(0, netIdentifiableAssets * (nciPct / 100)));
+    }
+
+    // 5. Acquisition Basis & Goodwill / Capital Reserve
+    const acquisitionBasis = roundToPaisa(totalConsiderationTransferred + nciAmount);
+    const excess = roundToPaisa(acquisitionBasis - netIdentifiableAssets);
+
+    let goodwillInr = 0;
+    let bargainPurchaseGainInr = 0;
+    let disposition = '';
+    let statutoryRationale = '';
+
+    if (excess > 0) {
+        goodwillInr = excess;
+        disposition = 'GOODWILL_RECOGNIZED';
+        statutoryRationale = `Ind AS 103 PPA complete: Consideration of INR ${totalConsiderationTransferred.toLocaleString('en-IN')} plus NCI of INR ${nciAmount.toLocaleString('en-IN')} exceeds Net Identifiable Assets of INR ${netIdentifiableAssets.toLocaleString('en-IN')}. Goodwill of INR ${goodwillInr.toLocaleString('en-IN')} capitalized on balance sheet. Mandatory annual impairment test under Ind AS 36 (amortization prohibited).`;
+    } else if (excess < 0) {
+        bargainPurchaseGainInr = Math.abs(excess);
+        disposition = 'BARGAIN_PURCHASE_CAPITAL_RESERVE';
+        statutoryRationale = `Ind AS 103 PPA complete: Net Identifiable Assets of INR ${netIdentifiableAssets.toLocaleString('en-IN')} exceed Acquisition Basis of INR ${acquisitionBasis.toLocaleString('en-IN')}. Bargain purchase gain of INR ${bargainPurchaseGainInr.toLocaleString('en-IN')} identified. After mandatory reassessment per Ind AS 103 paragraph 36, recognized in OCI and accumulated in Equity as Capital Reserve.`;
+    } else {
+        disposition = 'PAR_ACQUISITION';
+        statutoryRationale = `Ind AS 103 PPA complete: Acquisition Basis exactly equals Net Identifiable Assets of INR ${netIdentifiableAssets.toLocaleString('en-IN')}. Zero goodwill or bargain purchase gain recognized.`;
+    }
+
+    // 6. Acquisition-Related Costs (Expensed immediately in P&L)
+    const transactionCosts = roundToPaisa(cleanNumericAmount(params.acquisitionRelatedCostsInr, { defaultValue: 0 }));
+
+    // 7. General Ledger Journal Entries
+    const journalEntries = [];
+    if (tangibleAssets > 0) {
+        journalEntries.push({ account: 'Property, Plant & Equipment (Fair Value)', type: 'PPE', debitInr: tangibleAssets, creditInr: 0, reference: acquisitionId });
+    }
+    if (identifiableIntangibles > 0) {
+        journalEntries.push({ account: 'Identifiable Intangible Assets (Fair Value)', type: 'INTANGIBLE', debitInr: identifiableIntangibles, creditInr: 0, reference: acquisitionId });
+    }
+    if (otherAssets > 0) {
+        journalEntries.push({ account: 'Other Net Current Assets', type: 'CURRENT_ASSET', debitInr: otherAssets, creditInr: 0, reference: acquisitionId });
+    }
+    if (goodwillInr > 0) {
+        journalEntries.push({ account: 'Goodwill on Consolidation', type: 'INTANGIBLE_GOODWILL', debitInr: goodwillInr, creditInr: 0, reference: acquisitionId });
+    }
+    if (borrowings > 0) {
+        journalEntries.push({ account: 'Borrowings Assumed (Fair Value)', type: 'NON_CURRENT_LIABILITY', debitInr: 0, creditInr: borrowings, reference: acquisitionId });
+    }
+    if (workingCapitalLiab > 0) {
+        journalEntries.push({ account: 'Working Capital Liabilities Assumed', type: 'CURRENT_LIABILITY', debitInr: 0, creditInr: workingCapitalLiab, reference: acquisitionId });
+    }
+    if (contingentLiab > 0) {
+        journalEntries.push({ account: 'Contingent Liabilities Recognized', type: 'PROVISION', debitInr: 0, creditInr: contingentLiab, reference: acquisitionId });
+    }
+    if (deferredTaxLiability > 0) {
+        journalEntries.push({ account: 'Deferred Tax Liability (Ind AS 12 / Step-Up)', type: 'DTL', debitInr: 0, creditInr: deferredTaxLiability, reference: acquisitionId });
+    }
+    if (nciAmount > 0) {
+        journalEntries.push({ account: 'Non-Controlling Interest (Equity)', type: 'EQUITY_NCI', debitInr: 0, creditInr: nciAmount, reference: acquisitionId });
+    }
+    if (bargainPurchaseGainInr > 0) {
+        journalEntries.push({ account: 'Capital Reserve (Bargain Purchase Gain in OCI)', type: 'EQUITY_CAPITAL_RESERVE', debitInr: 0, creditInr: bargainPurchaseGainInr, reference: acquisitionId });
+    }
+    if (cashConsideration > 0) {
+        journalEntries.push({ account: 'Cash / Bank Rail Settlement', type: 'CURRENT_ASSET', debitInr: 0, creditInr: cashConsideration, reference: acquisitionId });
+    }
+    if (equitySharesFairValue > 0) {
+        journalEntries.push({ account: 'Equity Share Capital & Securities Premium', type: 'EQUITY', debitInr: 0, creditInr: equitySharesFairValue, reference: acquisitionId });
+    }
+    if (contingentConsideration > 0) {
+        journalEntries.push({ account: 'Contingent Consideration Liability', type: 'FINANCIAL_LIABILITY', debitInr: 0, creditInr: contingentConsideration, reference: acquisitionId });
+    }
+    if (deferredConsiderationPv > 0) {
+        journalEntries.push({ account: 'Deferred Consideration Payable (PV)', type: 'NON_CURRENT_LIABILITY', debitInr: 0, creditInr: deferredConsiderationPv, reference: acquisitionId });
+    }
+    if (preExistingInterest > 0) {
+        journalEntries.push({ account: 'Investment in Acquiree (Pre-existing Interest De-recognized)', type: 'INVESTMENT', debitInr: 0, creditInr: preExistingInterest, reference: acquisitionId });
+    }
+
+    if (transactionCosts > 0) {
+        journalEntries.push({ account: 'Acquisition Transaction Costs (P&L Expense)', type: 'OPERATING_EXPENSE', debitInr: transactionCosts, creditInr: 0, reference: acquisitionId });
+        journalEntries.push({ account: 'Accounts Payable / Bank (Advisory Fees)', type: 'CURRENT_LIABILITY', debitInr: 0, creditInr: transactionCosts, reference: acquisitionId });
+    }
+
+    const totalDebits = roundToPaisa(journalEntries.reduce((acc, e) => acc + e.debitInr, 0));
+    const totalCredits = roundToPaisa(journalEntries.reduce((acc, e) => acc + e.creditInr, 0));
+    const isDoubleEntryBalanced = Math.abs(totalDebits - totalCredits) < 0.001;
+
+    return {
+        status: 'SUCCESS',
+        standard: 'Ind AS 103 / IFRS 3 / US GAAP ASC 805',
+        acquisitionId,
+        acquirerName,
+        acquireeName,
+        acquisitionDate,
+        considerationSummary: {
+            cashConsiderationInr: cashConsideration,
+            equitySharesFairValueInr: equitySharesFairValue,
+            contingentConsiderationFairValueInr: contingentConsideration,
+            deferredConsiderationPresentValueInr: deferredConsiderationPv,
+            preExistingInterestFairValueInr: preExistingInterest,
+            totalConsiderationTransferredInr: totalConsiderationTransferred
+        },
+        netIdentifiableAssetsSummary: {
+            tangibleAssetsFairValueInr: tangibleAssets,
+            identifiableIntangiblesFairValueInr: identifiableIntangibles,
+            otherAssetsFairValueInr: otherAssets,
+            totalGrossAssetsFairValueInr: totalGrossAssets,
+            borrowingsFairValueInr: borrowings,
+            workingCapitalLiabilitiesInr: workingCapitalLiab,
+            contingentLiabilitiesRecognizedInr: contingentLiab,
+            deferredTaxLiabilityInr: deferredTaxLiability,
+            totalLiabilitiesAssumedInr: totalLiabilitiesAssumed,
+            netIdentifiableAssetsInr: netIdentifiableAssets
+        },
+        nonControllingInterestSummary: {
+            measurementMethod: nciMethod,
+            nciPercentage: nciPct,
+            nciAmountInr: nciAmount
+        },
+        purchasePriceAllocationOutcome: {
+            acquisitionBasisInr: acquisitionBasis,
+            netIdentifiableAssetsInr: netIdentifiableAssets,
+            disposition,
+            goodwillRecognizedInr: goodwillInr,
+            gainOnBargainPurchaseCapitalReserveInr: bargainPurchaseGainInr,
+            transactionCostsExpensedInr: transactionCosts
+        },
+        journalEntries,
+        isDoubleEntryBalanced,
+        isAuthorizedToDisburse: false,
+        statutoryRationale
+    };
+}
+
+/**
+ * Ind AS 115 / IFRS 15 / US GAAP ASC 606: 5-Step Revenue Recognition & Relative SSP Allocation Calculator.
+ */
+export function calculateRevenueAllocationIndAs115(params = {}) {
+    const rawPrice = cleanNumericAmount(params.transactionPrice, { defaultValue: 0 });
+    const transactionPrice = roundToPaisa(rawPrice);
+    const obligations = Array.isArray(params.performanceObligations) ? params.performanceObligations : [];
+
+    if (transactionPrice <= 0 || obligations.length === 0) {
+        return {
+            status: 'INSUFFICIENT_DATA',
+            standard: 'Ind AS 115 / IFRS 15 / US GAAP ASC 606',
+            transactionPriceInr: transactionPrice,
+            performanceObligationsCount: obligations.length,
+            isAuthorizedToDisburse: false,
+            statutoryRationale: 'Transaction price and at least one distinct performance obligation must be specified.'
+        };
+    }
+
+    let totalSsp = 0;
+    const prepped = obligations.map((ob, idx) => {
+        const ssp = roundToPaisa(cleanNumericAmount(ob.standaloneSellingPrice, { defaultValue: 0 }));
+        totalSsp += ssp;
+        return {
+            id: ob.id || `PO-${idx + 1}`,
+            description: ob.description || `Performance Obligation ${idx + 1}`,
+            standaloneSellingPrice: ssp,
+            satisfactionPattern: ob.satisfactionPattern === 'POINT_IN_TIME' ? 'POINT_IN_TIME' : 'OVER_TIME',
+            percentageCompletion: Math.min(100, Math.max(0, cleanNumericAmount(ob.percentageCompletion, { defaultValue: 0 }))),
+            termMonths: Math.max(0, cleanNumericAmount(ob.termMonths, { defaultValue: 0 })),
+            monthsElapsed: Math.max(0, cleanNumericAmount(ob.monthsElapsed, { defaultValue: 0 })),
+            isPointInTimeSatisfied: Boolean(ob.isPointInTimeSatisfied),
+            amountBilledToDate: roundToPaisa(cleanNumericAmount(ob.amountBilledToDate, { defaultValue: 0 }))
+        };
+    });
+
+    totalSsp = roundToPaisa(totalSsp);
+    const sspDenominator = totalSsp > 0 ? totalSsp : transactionPrice;
+    const bundleDiscount = roundToPaisa(Math.max(0, totalSsp - transactionPrice));
+    const bundleDiscountPercentage = totalSsp > 0 ? Number(((bundleDiscount / totalSsp) * 100).toFixed(2)) : 0;
+
+    let allocatedSum = 0;
+    let totalRevenueRecognized = 0;
+    let totalBilled = 0;
+
+    const allocatedObligations = prepped.map((ob, idx) => {
+        let allocatedAmount = 0;
+        if (idx === prepped.length - 1) {
+            allocatedAmount = roundToPaisa(transactionPrice - allocatedSum);
+        } else {
+            const ratio = ob.standaloneSellingPrice / sspDenominator;
+            allocatedAmount = roundToPaisa(transactionPrice * ratio);
+            allocatedSum = roundToPaisa(allocatedSum + allocatedAmount);
+        }
+
+        let revenueRecognized = 0;
+        let satisfactionProgressPercent = 0;
+
+        if (ob.satisfactionPattern === 'POINT_IN_TIME') {
+            if (ob.isPointInTimeSatisfied) {
+                revenueRecognized = allocatedAmount;
+                satisfactionProgressPercent = 100;
+            }
+        } else {
+            if (ob.percentageCompletion > 0) {
+                satisfactionProgressPercent = ob.percentageCompletion;
+                revenueRecognized = roundToPaisa(allocatedAmount * (ob.percentageCompletion / 100));
+            } else if (ob.termMonths > 0) {
+                const fraction = Math.min(1, ob.monthsElapsed / ob.termMonths);
+                satisfactionProgressPercent = Number((fraction * 100).toFixed(2));
+                revenueRecognized = roundToPaisa(allocatedAmount * fraction);
+            }
+        }
+
+        const unearnedDeferredRevenue = roundToPaisa(Math.max(0, allocatedAmount - revenueRecognized));
+        totalRevenueRecognized = roundToPaisa(totalRevenueRecognized + revenueRecognized);
+        totalBilled = roundToPaisa(totalBilled + ob.amountBilledToDate);
+
+        return {
+            id: ob.id,
+            description: ob.description,
+            standaloneSellingPriceInr: ob.standaloneSellingPrice,
+            sspWeightPercentage: Number(((ob.standaloneSellingPrice / sspDenominator) * 100).toFixed(2)),
+            allocatedTransactionPriceInr: allocatedAmount,
+            satisfactionPattern: ob.satisfactionPattern,
+            satisfactionProgressPercent,
+            cumulativeRevenueRecognizedInr: revenueRecognized,
+            unearnedDeferredRevenueInr: unearnedDeferredRevenue,
+            amountBilledToDateInr: ob.amountBilledToDate
+        };
+    });
+
+    const netContractPosition = roundToPaisa(totalRevenueRecognized - totalBilled);
+    const contractAssetUnbilled = netContractPosition > 0 ? netContractPosition : 0;
+    const contractLiabilityDeferred = netContractPosition < 0 ? Math.abs(netContractPosition) : 0;
+
+    return {
+        status: 'SUCCESS',
+        standard: 'Ind AS 115 / IFRS 15 / US GAAP ASC 606',
+        contractId: params.contractId || 'CONTRACT-UNSPECIFIED',
+        totalContractTransactionPriceInr: transactionPrice,
+        totalStandaloneSellingPriceInr: totalSsp,
+        bundleDiscountInr: bundleDiscount,
+        bundleDiscountPercentage,
+        allocatedObligations,
+        totalCumulativeRevenueRecognizedInr: totalRevenueRecognized,
+        totalBilledToDateInr: totalBilled,
+        contractBalanceSummary: {
+            netContractAssetUnbilledReceivableInr: contractAssetUnbilled,
+            netContractLiabilityDeferredRevenueInr: contractLiabilityDeferred,
+            disposition: contractAssetUnbilled > 0
+                ? 'CONTRACT_ASSET_UNBILLED_RECEIVABLE'
+                : (contractLiabilityDeferred > 0 ? 'CONTRACT_LIABILITY_DEFERRED_REVENUE' : 'CONTRACT_BALANCED')
+        },
+        isAuthorizedToDisburse: false,
+        statutoryRationale: `Ind AS 115 5-Step Evaluation complete: Relative SSP allocation on total contract price INR ${transactionPrice.toLocaleString('en-IN')} across ${allocatedObligations.length} obligations. Cumulative recognized revenue: INR ${totalRevenueRecognized.toLocaleString('en-IN')} vs billed INR ${totalBilled.toLocaleString('en-IN')}. Net contract balance: ${contractAssetUnbilled > 0 ? `Contract Asset INR ${contractAssetUnbilled.toLocaleString('en-IN')}` : `Contract Liability INR ${contractLiabilityDeferred.toLocaleString('en-IN')}`}.`
+    };
+}
+
+/**
+ * Ind AS 116 / IFRS 16 / US GAAP ASC 842: Right-of-Use (ROU) Asset & Lease Liability Amortization Schedule.
+ */
+export function calculateLeaseAmortizationIndAs116(params = {}) {
+    const monthlyPayment = roundToPaisa(cleanNumericAmount(params.monthlyPaymentInr, { defaultValue: 0 }));
+    const termMonths = Math.max(0, Math.floor(cleanNumericAmount(params.leaseTermMonths, { defaultValue: 0 })));
+    const annualRate = cleanNumericAmount(params.annualDiscountRate, { defaultValue: 0.085 });
+    const isAdvance = String(params.paymentTiming || 'ARREARS').toUpperCase().trim() === 'ADVANCE';
+    const directCosts = roundToPaisa(cleanNumericAmount(params.initialDirectCostsInr, { defaultValue: 0 }));
+    const incentives = roundToPaisa(cleanNumericAmount(params.leaseIncentivesReceivedInr, { defaultValue: 0 }));
+
+    if (params.electionShortTermExemption && termMonths <= 12) {
+        return {
+            status: 'EXEMPT_SHORT_TERM',
+            standard: 'Ind AS 116 / IFRS 16 / US GAAP ASC 842',
+            isCapitalizedOnBalanceSheet: false,
+            statutoryStatus: 'SHORT_TERM_LEASE_OFF_BALANCE_SHEET',
+            leaseTermMonths: termMonths,
+            monthlyPaymentInr: monthlyPayment,
+            monthlyStraightLinePnlExpenseInr: monthlyPayment,
+            totalUndiscountedCashPaymentsInr: roundToPaisa(monthlyPayment * termMonths),
+            initialPresentValueLeaseLiabilityInr: 0,
+            initialRightOfUseAssetInr: 0,
+            isAuthorizedToDisburse: false,
+            statutoryRationale: `Short-term lease exemption elected under Ind AS 116. Lease term of ${termMonths} months is <= 12 months without purchase option. Lease payments recognized as rent expense on straight-line basis in P&L. Off-balance sheet.`
+        };
+    }
+
+    if (params.electionLowValueExemption) {
+        return {
+            status: 'EXEMPT_LOW_VALUE',
+            standard: 'Ind AS 116 / IFRS 16 / US GAAP ASC 842',
+            isCapitalizedOnBalanceSheet: false,
+            statutoryStatus: 'LOW_VALUE_LEASE_OFF_BALANCE_SHEET',
+            leaseTermMonths: termMonths,
+            monthlyPaymentInr: monthlyPayment,
+            monthlyStraightLinePnlExpenseInr: monthlyPayment,
+            totalUndiscountedCashPaymentsInr: roundToPaisa(monthlyPayment * termMonths),
+            initialPresentValueLeaseLiabilityInr: 0,
+            initialRightOfUseAssetInr: 0,
+            isAuthorizedToDisburse: false,
+            statutoryRationale: 'Low-value underlying asset exemption elected under Ind AS 116. Lease payments recognized in P&L on straight-line basis. Off-balance sheet.'
+        };
+    }
+
+    if (monthlyPayment <= 0 || termMonths <= 0 || annualRate <= 0) {
+        return {
+            status: 'INSUFFICIENT_DATA',
+            standard: 'Ind AS 116 / IFRS 16 / US GAAP ASC 842',
+            isCapitalizedOnBalanceSheet: false,
+            isAuthorizedToDisburse: false,
+            statutoryRationale: 'Monthly payment, non-zero lease term, and positive incremental borrowing rate (IBR) are mandatory.'
+        };
+    }
+
+    const monthlyRate = annualRate / 12;
+    let pvMultiplier = (1 - Math.pow(1 + monthlyRate, -termMonths)) / monthlyRate;
+    if (isAdvance) {
+        pvMultiplier = pvMultiplier * (1 + monthlyRate);
+    }
+
+    const initialLiability = roundToPaisa(monthlyPayment * pvMultiplier);
+    const initialRouAsset = roundToPaisa(initialLiability + directCosts - incentives);
+    const monthlyDepreciation = roundToPaisa(initialRouAsset / termMonths);
+
+    let runningLiability = initialLiability;
+    let year1InterestTotal = 0;
+    let year1DepreciationTotal = 0;
+    let year1CashTotal = 0;
+    const monthlySchedules = [];
+
+    const previewMonths = Math.min(12, termMonths);
+    for (let m = 1; m <= previewMonths; m++) {
+        let interestExpense = 0;
+        let principalReduction = 0;
+
+        if (isAdvance && m === 1) {
+            interestExpense = 0;
+            principalReduction = monthlyPayment;
+            runningLiability = roundToPaisa(runningLiability - principalReduction);
+        } else {
+            interestExpense = roundToPaisa(runningLiability * monthlyRate);
+            principalReduction = roundToPaisa(monthlyPayment - interestExpense);
+            runningLiability = roundToPaisa(Math.max(0, runningLiability - principalReduction));
+        }
+
+        year1InterestTotal = roundToPaisa(year1InterestTotal + interestExpense);
+        year1DepreciationTotal = roundToPaisa(year1DepreciationTotal + monthlyDepreciation);
+        year1CashTotal = roundToPaisa(year1CashTotal + monthlyPayment);
+
+        monthlySchedules.push({
+            month: m,
+            openingLiabilityInr: isAdvance ? runningLiability : roundToPaisa(runningLiability + principalReduction),
+            paymentInr: monthlyPayment,
+            interestExpenseInr: interestExpense,
+            principalReductionInr: principalReduction,
+            closingLiabilityInr: runningLiability,
+            monthlyRouDepreciationInr: monthlyDepreciation
+        });
+    }
+
+    const totalUndiscountedCash = roundToPaisa(monthlyPayment * termMonths);
+    const totalLifetimeInterest = roundToPaisa(totalUndiscountedCash - initialLiability);
+
+    return {
+        status: 'SUCCESS',
+        standard: 'Ind AS 116 / IFRS 16 / US GAAP ASC 842',
+        isCapitalizedOnBalanceSheet: true,
+        leaseTermMonths: termMonths,
+        paymentTiming: isAdvance ? 'ADVANCE' : 'ARREARS',
+        annualDiscountRate: annualRate,
+        monthlyDiscountRate: Number(monthlyRate.toFixed(6)),
+        monthlyContractualPaymentInr: monthlyPayment,
+        totalUndiscountedCashPaymentsInr: totalUndiscountedCash,
+        initialPresentValueLeaseLiabilityInr: initialLiability,
+        initialRightOfUseAssetInr: initialRouAsset,
+        monthlyStraightLineDepreciationInr: monthlyDepreciation,
+        totalLifetimeInterestExpenseInr: totalLifetimeInterest,
+        year1Summary: {
+            year1CashPaymentsInr: year1CashTotal,
+            year1InterestExpenseInr: year1InterestTotal,
+            year1DepreciationExpenseInr: year1DepreciationTotal,
+            year1TotalPnlExpenseInr: roundToPaisa(year1InterestTotal + year1DepreciationTotal),
+            year1FrontLoadedVarianceInr: roundToPaisa((year1InterestTotal + year1DepreciationTotal) - year1CashTotal)
+        },
+        first12MonthsAmortizationPreview: monthlySchedules,
+        isAuthorizedToDisburse: false,
+        statutoryRationale: `Ind AS 116 on-balance-sheet capitalization active: Present value of future lease payments discounted at ${(annualRate * 100).toFixed(2)}% IBR yields initial Lease Liability of INR ${initialLiability.toLocaleString('en-IN')} and initial ROU Asset of INR ${initialRouAsset.toLocaleString('en-IN')}. Monthly straight-line depreciation: INR ${monthlyDepreciation.toLocaleString('en-IN')}. Year 1 P&L charge: INR ${(year1InterestTotal + year1DepreciationTotal).toLocaleString('en-IN')} (Interest: INR ${year1InterestTotal.toLocaleString('en-IN')}, Depreciation: INR ${year1DepreciationTotal.toLocaleString('en-IN')}).`
+    };
+}
+
+/**
+ * Ind AS 109 / IFRS 9 / US GAAP ASC 326: Expected Credit Loss (ECL) Impairment Calculator.
+ */
+export function calculateExpectedCreditLossIndAs109(params = {}) {
+    const grossTotal = roundToPaisa(cleanNumericAmount(params.grossTradeReceivablesInr, { defaultValue: 0 }));
+    const rawBuckets = Array.isArray(params.agingBuckets) ? params.agingBuckets : [];
+    const macroFactor = cleanNumericAmount(params.macroeconomicAdjustmentFactor, { defaultValue: 1.0 });
+    const lgdPercent = cleanNumericAmount(params.lossGivenDefaultPercent, { defaultValue: 100.0 });
+    const asOfDate = params.reportingDate || new Date().toISOString().split('T')[0];
+
+    if (grossTotal <= 0 && rawBuckets.length === 0) {
+        return {
+            status: 'INSUFFICIENT_DATA',
+            standard: 'Ind AS 109 / IFRS 9 / US GAAP ASC 326',
+            isAuthorizedToDisburse: false,
+            statutoryRationale: 'Gross trade receivables or non-empty aging buckets are mandatory.'
+        };
+    }
+
+    let totalComputedGross = 0;
+    let totalLossAllowance = 0;
+    let stage1Allowance = 0;
+    let stage2Allowance = 0;
+    let stage3Allowance = 0;
+    let stage1Gross = 0;
+    let stage2Gross = 0;
+    let stage3Gross = 0;
+
+    const evaluatedBuckets = rawBuckets.map((b, idx) => {
+        const bucketGross = roundToPaisa(cleanNumericAmount(b.grossAmountInr, { defaultValue: 0 }));
+        const histRate = cleanNumericAmount(b.historicalDefaultRatePercent, { defaultValue: 0 });
+        const stage = Number(b.stage || (idx === 0 ? 1 : (idx === rawBuckets.length - 1 ? 3 : 2)));
+
+        const effectiveLossRatePercent = Number(Math.min(100, Math.max(0, histRate * macroFactor * (lgdPercent / 100))).toFixed(4));
+        const allowance = roundToPaisa(bucketGross * (effectiveLossRatePercent / 100));
+        const netCarryingAmount = roundToPaisa(bucketGross - allowance);
+
+        totalComputedGross = roundToPaisa(totalComputedGross + bucketGross);
+        totalLossAllowance = roundToPaisa(totalLossAllowance + allowance);
+
+        if (stage === 1) {
+            stage1Gross = roundToPaisa(stage1Gross + bucketGross);
+            stage1Allowance = roundToPaisa(stage1Allowance + allowance);
+        } else if (stage === 2) {
+            stage2Gross = roundToPaisa(stage2Gross + bucketGross);
+            stage2Allowance = roundToPaisa(stage2Allowance + allowance);
+        } else {
+            stage3Gross = roundToPaisa(stage3Gross + bucketGross);
+            stage3Allowance = roundToPaisa(stage3Allowance + allowance);
+        }
+
+        return {
+            bucketLabel: b.bucketLabel || `Bracket-${idx + 1}`,
+            grossAmountInr: bucketGross,
+            stage,
+            historicalDefaultRatePercent: histRate,
+            effectiveLossRatePercent,
+            lossAllowanceInr: allowance,
+            netCarryingAmountInr: netCarryingAmount
+        };
+    });
+
+    const reconciledGross = grossTotal > 0 ? grossTotal : totalComputedGross;
+    const netReceivables = roundToPaisa(reconciledGross - totalLossAllowance);
+    const overallEffectiveRate = reconciledGross > 0 ? Number(((totalLossAllowance / reconciledGross) * 100).toFixed(2)) : 0;
+
+    return {
+        status: 'SUCCESS',
+        standard: 'Ind AS 109 / IFRS 9 / US GAAP ASC 326',
+        asOfDate,
+        grossTradeReceivablesInr: reconciledGross,
+        totalExpectedCreditLossAllowanceInr: totalLossAllowance,
+        netTradeReceivablesCarryingAmountInr: netReceivables,
+        overallEffectiveLossRatePercent: overallEffectiveRate,
+        macroeconomicAdjustmentFactor: macroFactor,
+        stagingSummary: {
+            stage1: { grossInr: stage1Gross, allowanceInr: stage1Allowance, label: '12-Month ECL (Performing)' },
+            stage2: { grossInr: stage2Gross, allowanceInr: stage2Allowance, label: 'Lifetime ECL (SICR / Underperforming)' },
+            stage3: { grossInr: stage3Gross, allowanceInr: stage3Allowance, label: 'Lifetime ECL (Credit Impaired / Default)' }
+        },
+        agingBuckets: evaluatedBuckets,
+        taxTreatment: {
+            isTaxDeductibleInCurrentYear: false,
+            statutoryAddBackSection: 'Section 36(1)(vii) read with Section 40A(9) Income-tax Act, 1961',
+            taxConsequence: `ECL impairment provision of INR ${totalLossAllowance.toLocaleString('en-IN')} is not deductible for Indian corporate tax purposes until actual bad debt write-off. Recognizes a Deferred Tax Asset (DTA) under Ind AS 12.`
+        },
+        isAuthorizedToDisburse: false,
+        statutoryRationale: `Ind AS 109 Simplified Approach: Expected Credit Loss provision of INR ${totalLossAllowance.toLocaleString('en-IN')} computed on gross receivables of INR ${reconciledGross.toLocaleString('en-IN')} (overall rate: ${overallEffectiveRate}%). Net receivables on balance sheet: INR ${netReceivables.toLocaleString('en-IN')}. Accounting impairment does not authorize fund disbursement.`
+    };
+}
+
+/**
+ * Ind AS 102 / IFRS 2 / US GAAP ASC 718: ESOP Graded Vesting Amortization Calculator.
+ */
+export function calculateEsopAmortizationIndAs102(params = {}) {
+    const totalOptions = Math.max(0, Math.floor(cleanNumericAmount(params.totalOptionsGranted, { defaultValue: 0 })));
+    const fairValuePerOption = roundToPaisa(cleanNumericAmount(params.grantDateFairValuePerOptionInr, { defaultValue: 0 }));
+    const defaultTranches = [
+        { trancheNumber: 1, vestingYears: 1, allocationPercentage: 25, expectedForfeitureRate: 0 },
+        { trancheNumber: 2, vestingYears: 2, allocationPercentage: 25, expectedForfeitureRate: 0 },
+        { trancheNumber: 3, vestingYears: 3, allocationPercentage: 25, expectedForfeitureRate: 0 },
+        { trancheNumber: 4, vestingYears: 4, allocationPercentage: 25, expectedForfeitureRate: 0 }
+    ];
+    const tranches = Array.isArray(params.vestingTranches) && params.vestingTranches.length > 0 ? params.vestingTranches : defaultTranches;
+
+    if (totalOptions <= 0 || fairValuePerOption <= 0) {
+        return {
+            status: 'INSUFFICIENT_DATA',
+            standard: 'Ind AS 102 / IFRS 2 / US GAAP ASC 718',
+            isAuthorizedToDisburse: false,
+            statutoryRationale: 'Total options granted and positive grant-date fair value per option are mandatory.'
+        };
+    }
+
+    const totalGrantDateFairValue = roundToPaisa(totalOptions * fairValuePerOption);
+    let maxVestingYear = 1;
+    let totalAllocatedOptions = 0;
+    let totalAdjustedFairValue = 0;
+
+    const processedTranches = tranches.map((t, idx) => {
+        const trancheNum = t.trancheNumber || idx + 1;
+        const years = Math.max(0.5, cleanNumericAmount(t.vestingYears, { defaultValue: idx + 1 }));
+        if (years > maxVestingYear) maxVestingYear = Math.ceil(years);
+
+        const allocPct = cleanNumericAmount(t.allocationPercentage, { defaultValue: 100 / tranches.length });
+        const forfeitRate = cleanNumericAmount(t.expectedForfeitureRate, { defaultValue: 0 });
+
+        const nominalOptions = Math.floor(totalOptions * (allocPct / 100));
+        const effectiveOptions = Math.floor(nominalOptions * (1 - forfeitRate / 100));
+        const trancheFairValue = roundToPaisa(effectiveOptions * fairValuePerOption);
+        const annualAmortization = roundToPaisa(trancheFairValue / years);
+
+        totalAllocatedOptions += effectiveOptions;
+        totalAdjustedFairValue = roundToPaisa(totalAdjustedFairValue + trancheFairValue);
+
+        return {
+            trancheNumber: trancheNum,
+            vestingYears: years,
+            allocationPercentage: allocPct,
+            expectedForfeitureRatePercent: forfeitRate,
+            effectiveOptionsGranted: effectiveOptions,
+            trancheGrantDateFairValueInr: trancheFairValue,
+            annualAmortizationExpenseInr: annualAmortization
+        };
+    });
+
+    const yearlyExpenseProfile = [];
+    let cumulativeExpense = 0;
+    for (let yr = 1; yr <= maxVestingYear; yr++) {
+        let yearExpense = 0;
+        for (const pt of processedTranches) {
+            if (yr <= Math.ceil(pt.vestingYears)) {
+                yearExpense = roundToPaisa(yearExpense + pt.annualAmortizationExpenseInr);
+            }
+        }
+        cumulativeExpense = roundToPaisa(cumulativeExpense + yearExpense);
+        yearlyExpenseProfile.push({
+            year: yr,
+            pnlCompensationExpenseInr: yearExpense,
+            cumulativeExpenseRecognizedInr: cumulativeExpense,
+            closingShareBasedPaymentReserveInr: cumulativeExpense
+        });
+    }
+
+    const year1Expense = yearlyExpenseProfile.length > 0 ? yearlyExpenseProfile[0].pnlCompensationExpenseInr : 0;
+    const flatStraightLineAverage = roundToPaisa(totalAdjustedFairValue / maxVestingYear);
+    const isFrontLoaded = year1Expense > flatStraightLineAverage;
+
+    return {
+        status: 'SUCCESS',
+        standard: 'Ind AS 102 / IFRS 2 / US GAAP ASC 718',
+        schemeName: params.schemeName || 'SCHEME-DEFAULT-ESOP',
+        totalOptionsGranted: totalOptions,
+        effectiveVestingOptions: totalAllocatedOptions,
+        grantDateFairValuePerOptionInr: fairValuePerOption,
+        totalNominalGrantDateFairValueInr: totalGrantDateFairValue,
+        totalNetFairValueToExpenseInr: totalAdjustedFairValue,
+        maxVestingYears: maxVestingYear,
+        isGradedVestingFrontLoaded: isFrontLoaded,
+        year1ExpenseComparison: {
+            year1GradedVestingExpenseInr: year1Expense,
+            hypotheticalFlatAverageInr: flatStraightLineAverage,
+            frontLoadingAccelerationInr: roundToPaisa(year1Expense - flatStraightLineAverage)
+        },
+        vestingTranches: processedTranches,
+        yearlyExpenseProfile,
+        taxTreatment: {
+            statutoryDeductionSection: 'Section 37(1) Income-tax Act, 1961 (Biocon Special Bench Principle)',
+            perquisiteTaxSection: 'Section 17(2)(vi) read with Rule 3(8) Income-tax Rules, 1962',
+            deductibilitySummary: `Company is eligible to claim ESOP discount as an allowable business deduction under Section 37(1) spread over the vesting period. Upon exercise, employee is subject to salary TDS under Section 192 on perquisite value (FMV on exercise date minus exercise price).`
+        },
+        isAuthorizedToDisburse: false,
+        statutoryRationale: `Ind AS 102 Graded Vesting: Total ESOP fair value INR ${totalAdjustedFairValue.toLocaleString('en-IN')} across ${processedTranches.length} tranches. Mandatory separate-tranche accounting produces Year 1 front-loaded expense of INR ${year1Expense.toLocaleString('en-IN')} (vs flat average INR ${flatStraightLineAverage.toLocaleString('en-IN')}). Share-based compensation does not authorize cash disbursement.`
+    };
+}
+
+/**
+ * Ind AS 12 / IAS 12 / US GAAP ASC 740: Income Taxes & Deferred Tax (DTA / DTL) Calculator.
+ */
+export function calculateDeferredTaxIndAs12(params = {}) {
+    const bookProfit = roundToPaisa(cleanNumericAmount(params.accountingProfitBeforeTaxInr, { defaultValue: 0 }));
+    const taxRatePercent = cleanNumericAmount(params.enactedTaxRatePercent, { defaultValue: 25.168 });
+    const taxRate = taxRatePercent / 100;
+    const diffs = params.temporaryDifferences || {};
+    const permanentDiffs = roundToPaisa(cleanNumericAmount(params.permanentDifferencesInr, { defaultValue: 0 }));
+    const openingNetDta = roundToPaisa(cleanNumericAmount(params.openingNetDtaInr, { defaultValue: 0 }));
+    const fy = params.financialYear || '2025-26';
+
+    if (taxRate <= 0) {
+        return {
+            status: 'INSUFFICIENT_DATA',
+            standard: 'Ind AS 12 / IAS 12 / US GAAP ASC 740',
+            isAuthorizedToDisburse: false,
+            statutoryRationale: 'Positive enacted tax rate is mandatory.'
+        };
+    }
+
+    const msme43bH = roundToPaisa(cleanNumericAmount(diffs.msmeDisallowanceSec43bHInr, { defaultValue: 0 }));
+    const statutory43B = roundToPaisa(cleanNumericAmount(diffs.statutoryDuesUnpaidSec43BInr, { defaultValue: 0 }));
+    const ecl109 = roundToPaisa(cleanNumericAmount(diffs.eclLossAllowanceIndAs109Inr, { defaultValue: 0 }));
+    const lease116 = roundToPaisa(cleanNumericAmount(diffs.leaseLiabilityNetIndAs116Inr, { defaultValue: 0 }));
+    const esop102 = roundToPaisa(cleanNumericAmount(diffs.esopReserveUnvestedIndAs102Inr, { defaultValue: 0 }));
+    const otherDeductible = roundToPaisa(cleanNumericAmount(diffs.otherDeductibleDifferencesInr, { defaultValue: 0 }));
+
+    const totalDeductibleDifferences = roundToPaisa(msme43bH + statutory43B + ecl109 + lease116 + esop102 + otherDeductible);
+    const grossDta = roundToPaisa(totalDeductibleDifferences * taxRate);
+
+    const accelDep32 = roundToPaisa(cleanNumericAmount(diffs.acceleratedTaxDepreciationSec32Inr, { defaultValue: 0 }));
+    const otherTaxable = roundToPaisa(cleanNumericAmount(diffs.otherTaxableDifferencesInr, { defaultValue: 0 }));
+
+    const totalTaxableDifferences = roundToPaisa(accelDep32 + otherTaxable);
+    const grossDtl = roundToPaisa(totalTaxableDifferences * taxRate);
+
+    const netDeferredTaxBalance = roundToPaisa(grossDta - grossDtl);
+    const closingNetDta = netDeferredTaxBalance > 0 ? netDeferredTaxBalance : 0;
+    const closingNetDtl = netDeferredTaxBalance < 0 ? Math.abs(netDeferredTaxBalance) : 0;
+
+    const taxableProfit = roundToPaisa(Math.max(0, bookProfit + totalDeductibleDifferences - totalTaxableDifferences + permanentDiffs));
+    const currentTaxExpense = roundToPaisa(taxableProfit * taxRate);
+
+    const deferredTaxPnlCharge = roundToPaisa(openingNetDta - netDeferredTaxBalance);
+    const totalTaxExpense = roundToPaisa(currentTaxExpense + deferredTaxPnlCharge);
+
+    const theoreticalTaxOnBookProfit = roundToPaisa(bookProfit * taxRate);
+    const taxEffectPermanent = roundToPaisa(permanentDiffs * taxRate);
+    const effectiveTaxRatePercent = bookProfit > 0 ? Number(((totalTaxExpense / bookProfit) * 100).toFixed(2)) : 0;
+
+    return {
+        status: 'SUCCESS',
+        standard: 'Ind AS 12 / IAS 12 / US GAAP ASC 740',
+        financialYear: fy,
+        accountingProfitBeforeTaxInr: bookProfit,
+        enactedCorporateTaxRatePercent: taxRatePercent,
+        taxableProfitForIncomeTaxInr: taxableProfit,
+        currentTaxLiabilityInr: currentTaxExpense,
+        temporaryDifferencesSummary: {
+            totalDeductibleDifferencesInr: totalDeductibleDifferences,
+            totalTaxableDifferencesInr: totalTaxableDifferences,
+            netTemporaryDifferenceInr: roundToPaisa(totalDeductibleDifferences - totalTaxableDifferences),
+            breakdown: {
+                msmeDisallowanceSec43bHInr: msme43bH,
+                statutoryDuesSec43BInr: statutory43B,
+                eclLossAllowanceIndAs109Inr: ecl109,
+                leaseNetIndAs116Inr: lease116,
+                esopReserveIndAs102Inr: esop102,
+                acceleratedTaxDepreciationSec32Inr: accelDep32
+            }
+        },
+        balanceSheetPosition: {
+            grossDeferredTaxAssetInr: grossDta,
+            grossDeferredTaxLiabilityInr: grossDtl,
+            netDeferredTaxAssetBalanceSheetInr: closingNetDta,
+            netDeferredTaxLiabilityBalanceSheetInr: closingNetDtl,
+            disposition: closingNetDta > 0 ? 'NET_DEFERRED_TAX_ASSET' : (closingNetDtl > 0 ? 'NET_DEFERRED_TAX_LIABILITY' : 'BALANCED')
+        },
+        statementOfProfitAndLossTaxExpense: {
+            currentTaxExpenseInr: currentTaxExpense,
+            deferredTaxExpenseOrCreditInr: deferredTaxPnlCharge,
+            totalTaxExpenseInr: totalTaxExpense
+        },
+        effectiveTaxRateReconciliation: {
+            theoreticalTaxExpenseAtStatutoryRateInr: theoreticalTaxOnBookProfit,
+            taxEffectOfPermanentDifferencesInr: taxEffectPermanent,
+            reconciledTotalTaxExpenseInr: totalTaxExpense,
+            effectiveTaxRatePercent,
+            statutoryTaxRatePercent: taxRatePercent,
+            rateVariancePercent: Number((effectiveTaxRatePercent - taxRatePercent).toFixed(2))
+        },
+        isAuthorizedToDisburse: false,
+        statutoryRationale: `Ind AS 12 Balance Sheet Method: Current Tax of INR ${currentTaxExpense.toLocaleString('en-IN')} (Taxable Profit: INR ${taxableProfit.toLocaleString('en-IN')}). Closing Net ${closingNetDta > 0 ? `DTA of INR ${closingNetDta.toLocaleString('en-IN')}` : `DTL of INR ${closingNetDtl.toLocaleString('en-IN')}`}. Total P&L Tax Expense: INR ${totalTaxExpense.toLocaleString('en-IN')} (ETR: ${effectiveTaxRatePercent}% vs statutory ${taxRatePercent}%). Tax calculations do not authorize payment disbursement.`
+    };
+}
+
+/**
+ * Ind AS 37 / IAS 37 / US GAAP ASC 450: Provisions, Contingent Liabilities & Contingent Assets Evaluator.
+ */
+export function evaluateProvisionsAndContingenciesIndAs37(params = {}) {
+    const rawItems = Array.isArray(params.exposureItems) ? params.exposureItems : [];
+    const asOfDate = params.reportingDate || new Date().toISOString().split('T')[0];
+
+    if (rawItems.length === 0) {
+        return {
+            status: 'INSUFFICIENT_DATA',
+            standard: 'Ind AS 37 / IAS 37 / US GAAP ASC 450',
+            isAuthorizedToDisburse: false,
+            statutoryRationale: 'At least one exposure item must be provided for evaluation.'
+        };
+    }
+
+    let totalProvisionsAccrued = 0;
+    let totalContingentLiabilities = 0;
+    let totalRemoteExposures = 0;
+    let totalReimbursements = 0;
+
+    const classifiedItems = rawItems.map((item, idx) => {
+        const claimId = item.claimId || `EXP-${idx + 1}`;
+        const desc = item.description || `Exposure item ${idx + 1}`;
+        const claimedAmt = roundToPaisa(cleanNumericAmount(item.claimedAmountInr, { defaultValue: 0 }));
+        const estimateAmt = roundToPaisa(cleanNumericAmount(item.bestEstimateAmountInr, { defaultValue: claimedAmt }));
+        const prob = cleanNumericAmount(item.outflowProbabilityPercent, { defaultValue: 0 });
+        const measurable = item.isReliablyMeasurable !== false;
+        const reimb = roundToPaisa(cleanNumericAmount(item.expectedReimbursementInr, { defaultValue: 0 }));
+        const disputeType = item.disputeType || 'STATUTORY_TAX_DISPUTE';
+
+        let classification = '';
+        let accountingTreatment = '';
+        let provisionAmount = 0;
+        let contingentAmount = 0;
+        let remoteAmount = 0;
+
+        if (prob > 50 && measurable) {
+            classification = 'PROVISION_RECOGNIZED_ON_BALANCE_SHEET';
+            provisionAmount = Math.max(0, roundToPaisa(estimateAmt - reimb));
+            accountingTreatment = 'Recognize accrued liability on balance sheet and charge expense to profit or loss.';
+            totalProvisionsAccrued = roundToPaisa(totalProvisionsAccrued + provisionAmount);
+            totalReimbursements = roundToPaisa(totalReimbursements + reimb);
+        } else if (prob >= 5 || (prob > 50 && !measurable)) {
+            classification = 'CONTINGENT_LIABILITY_DISCLOSED_IN_NOTES';
+            contingentAmount = estimateAmt;
+            accountingTreatment = 'Do not recognize liability on balance sheet. Disclose in Schedule III Notes to Accounts.';
+            totalContingentLiabilities = roundToPaisa(totalContingentLiabilities + contingentAmount);
+        } else {
+            classification = 'REMOTE_NO_DISCLOSURE_REQUIRED';
+            remoteAmount = estimateAmt;
+            accountingTreatment = 'Outflow probability is remote (< 5%). Neither recognition nor disclosure required.';
+            totalRemoteExposures = roundToPaisa(totalRemoteExposures + remoteAmount);
+        }
+
+        return {
+            claimId,
+            description: desc,
+            disputeType,
+            claimedAmountInr: claimedAmt,
+            bestEstimateAmountInr: estimateAmt,
+            outflowProbabilityPercent: prob,
+            isReliablyMeasurable: measurable,
+            classification,
+            accountingTreatment,
+            provisionRecognizedInr: provisionAmount,
+            contingentLiabilityDisclosedInr: contingentAmount,
+            remoteAmountInr: remoteAmount,
+            expectedReimbursementInr: reimb
+        };
+    });
+
+    return {
+        status: 'SUCCESS',
+        standard: 'Ind AS 37 / IAS 37 / US GAAP ASC 450',
+        asOfDate,
+        totalItemsEvaluated: classifiedItems.length,
+        summary: {
+            totalProvisionsAccruedOnBalanceSheetInr: totalProvisionsAccrued,
+            totalContingentLiabilitiesDisclosedInNotesInr: totalContingentLiabilities,
+            totalRemoteExposuresNoDisclosureInr: totalRemoteExposures,
+            totalExpectedReimbursementsInr: totalReimbursements
+        },
+        classifiedExposures: classifiedItems,
+        scheduleThreeDisclosureNote: `Contingent Liabilities and Commitments (to the extent not provided for): The company has contingent liabilities of INR ${totalContingentLiabilities.toLocaleString('en-IN')} in respect of disputed statutory demands and claims under appeal where adverse outflow is possible (5%-50%) but not probable. Balance sheet provisions of INR ${totalProvisionsAccrued.toLocaleString('en-IN')} have been recognized where outflow is probable (> 50%).`,
+        isAuthorizedToDisburse: false,
+        statutoryRationale: `Ind AS 37 Evaluation complete: ${classifiedItems.length} exposures evaluated. Balance Sheet Provisions accrued: INR ${totalProvisionsAccrued.toLocaleString('en-IN')}; Footnote Contingent Liabilities: INR ${totalContingentLiabilities.toLocaleString('en-IN')}; Remote exclusions: INR ${totalRemoteExposures.toLocaleString('en-IN')}. Evaluation of legal claims does not authorize payment disbursement.`
+    };
+}
+
+/**
+ * Ind AS 21 / IAS 21 / US GAAP ASC 830: Foreign Currency Monetary Revaluation & FCTR Translation Calculator.
+ */
+export function calculateForeignCurrencyIndAs21(params = {}) {
+    const asOfDate = params.asOfDate || new Date().toISOString().split('T')[0];
+    const functionalCurrency = params.functionalCurrency || 'INR';
+    const rawItems = Array.isArray(params.items) ? params.items : [];
+    const foreignOps = Array.isArray(params.foreignOperations) ? params.foreignOperations : [];
+
+    if (rawItems.length === 0 && foreignOps.length === 0) {
+        return {
+            status: 'INSUFFICIENT_DATA',
+            standard: 'Ind AS 21 / IAS 21 / US GAAP ASC 830',
+            asOfDate,
+            itemsCount: 0,
+            isAuthorizedToDisburse: false,
+            statutoryRationale: 'At least one foreign currency item or foreign operation package must be provided for evaluation.'
+        };
+    }
+
+    let totalOriginalBookValueInr = 0;
+    let totalClosingBookValueInr = 0;
+    let totalUnrealizedGainInr = 0;
+    let totalUnrealizedLossInr = 0;
+    const journalEntries = [];
+
+    const revaluedItems = rawItems.map((item, idx) => {
+        const id = item.id || `FX-ITEM-${idx + 1}`;
+        const description = item.description || `Foreign Currency Exposure ${idx + 1}`;
+        const itemType = String(item.itemType || 'MONETARY_ASSET').toUpperCase().trim();
+        const foreignCurrency = item.foreignCurrency || 'USD';
+        const foreignAmount = cleanNumericAmount(item.foreignAmount, { defaultValue: 0 });
+        const bookingRate = cleanNumericAmount(item.bookingRate, { defaultValue: 1 });
+        const closingRate = cleanNumericAmount(item.closingRate, { defaultValue: bookingRate });
+
+        const originalBookValueInr = roundToPaisa(foreignAmount * bookingRate);
+        totalOriginalBookValueInr = roundToPaisa(totalOriginalBookValueInr + originalBookValueInr);
+
+        let closingBookValueInr = originalBookValueInr;
+        let unrealizedGainLossInr = 0;
+        let treatment = '';
+        let glImpact = 'NONE';
+
+        if (itemType === 'NON_MONETARY_HISTORICAL') {
+            closingBookValueInr = originalBookValueInr;
+            unrealizedGainLossInr = 0;
+            treatment = 'Carried at historical exchange rate under Ind AS 21.23(b). No closing revaluation recognized.';
+        } else if (itemType === 'MONETARY_ASSET') {
+            closingBookValueInr = roundToPaisa(foreignAmount * closingRate);
+            unrealizedGainLossInr = roundToPaisa(closingBookValueInr - originalBookValueInr);
+
+            if (unrealizedGainLossInr > 0) {
+                treatment = 'Unrealized foreign exchange gain credited to Statement of Profit & Loss.';
+                glImpact = 'CREDIT_PL_GAIN';
+                totalUnrealizedGainInr = roundToPaisa(totalUnrealizedGainInr + unrealizedGainLossInr);
+                journalEntries.push({
+                    account: `Foreign Trade Receivables (${foreignCurrency})`,
+                    type: 'CURRENT_ASSET',
+                    debitInr: unrealizedGainLossInr,
+                    creditInr: 0,
+                    reference: id
+                });
+                journalEntries.push({
+                    account: 'Foreign Exchange Fluctuation Gain (P&L)',
+                    type: 'OTHER_INCOME',
+                    debitInr: 0,
+                    creditInr: unrealizedGainLossInr,
+                    reference: id
+                });
+            } else if (unrealizedGainLossInr < 0) {
+                const lossAmt = Math.abs(unrealizedGainLossInr);
+                treatment = 'Unrealized foreign exchange loss debited to Statement of Profit & Loss.';
+                glImpact = 'DEBIT_PL_LOSS';
+                totalUnrealizedLossInr = roundToPaisa(totalUnrealizedLossInr + lossAmt);
+                journalEntries.push({
+                    account: 'Foreign Exchange Fluctuation Loss (P&L)',
+                    type: 'FINANCE_EXPENSE',
+                    debitInr: lossAmt,
+                    creditInr: 0,
+                    reference: id
+                });
+                journalEntries.push({
+                    account: `Foreign Trade Receivables (${foreignCurrency})`,
+                    type: 'CURRENT_ASSET',
+                    debitInr: 0,
+                    creditInr: lossAmt,
+                    reference: id
+                });
+            } else {
+                treatment = 'No foreign exchange variance detected at reporting date.';
+            }
+        } else if (itemType === 'MONETARY_LIABILITY') {
+            closingBookValueInr = roundToPaisa(foreignAmount * closingRate);
+            unrealizedGainLossInr = roundToPaisa(originalBookValueInr - closingBookValueInr);
+
+            if (unrealizedGainLossInr > 0) {
+                treatment = 'Unrealized foreign exchange gain (liability reduction) credited to P&L.';
+                glImpact = 'CREDIT_PL_GAIN';
+                totalUnrealizedGainInr = roundToPaisa(totalUnrealizedGainInr + unrealizedGainLossInr);
+                journalEntries.push({
+                    account: `Foreign Trade Payables (${foreignCurrency})`,
+                    type: 'CURRENT_LIABILITY',
+                    debitInr: unrealizedGainLossInr,
+                    creditInr: 0,
+                    reference: id
+                });
+                journalEntries.push({
+                    account: 'Foreign Exchange Fluctuation Gain (P&L)',
+                    type: 'OTHER_INCOME',
+                    debitInr: 0,
+                    creditInr: unrealizedGainLossInr,
+                    reference: id
+                });
+            } else if (unrealizedGainLossInr < 0) {
+                const lossAmt = Math.abs(unrealizedGainLossInr);
+                treatment = 'Unrealized foreign exchange loss (liability expansion) debited to P&L.';
+                glImpact = 'DEBIT_PL_LOSS';
+                totalUnrealizedLossInr = roundToPaisa(totalUnrealizedLossInr + lossAmt);
+                journalEntries.push({
+                    account: 'Foreign Exchange Fluctuation Loss (P&L)',
+                    type: 'FINANCE_EXPENSE',
+                    debitInr: lossAmt,
+                    creditInr: 0,
+                    reference: id
+                });
+                journalEntries.push({
+                    account: `Foreign Trade Payables (${foreignCurrency})`,
+                    type: 'CURRENT_LIABILITY',
+                    debitInr: 0,
+                    creditInr: lossAmt,
+                    reference: id
+                });
+            } else {
+                treatment = 'No foreign exchange variance detected at reporting date.';
+            }
+        }
+
+        totalClosingBookValueInr = roundToPaisa(totalClosingBookValueInr + closingBookValueInr);
+
+        return {
+            id,
+            description,
+            itemType,
+            foreignCurrency,
+            foreignAmount,
+            bookingRate,
+            closingRate,
+            originalBookValueInr,
+            closingBookValueInr,
+            unrealizedGainLossInr,
+            treatment,
+            glImpact
+        };
+    });
+
+    const netUnrealizedPnLInr = roundToPaisa(totalUnrealizedGainInr - totalUnrealizedLossInr);
+
+    let totalFctrReserveInr = 0;
+    const translatedOperations = foreignOps.map((op, idx) => {
+        const entityName = op.entityName || `Foreign Subsidiary ${idx + 1}`;
+        const closingRate = cleanNumericAmount(op.closingRate, { defaultValue: 1 });
+        const averageRate = cleanNumericAmount(op.averageRate, { defaultValue: closingRate });
+        const assetsForeign = cleanNumericAmount(op.totalAssetsForeign, { defaultValue: 0 });
+        const liabilitiesForeign = cleanNumericAmount(op.totalLiabilitiesForeign, { defaultValue: 0 });
+        const netIncomeForeign = cleanNumericAmount(op.netIncomeForeign, { defaultValue: 0 });
+        const shareCapitalInr = cleanNumericAmount(op.shareCapitalInr, { defaultValue: 0 });
+        const openingRetainedEarningsInr = cleanNumericAmount(op.openingRetainedEarningsInr, { defaultValue: 0 });
+
+        const assetsInr = roundToPaisa(assetsForeign * closingRate);
+        const liabilitiesInr = roundToPaisa(liabilitiesForeign * closingRate);
+        const netAssetsClosingInr = roundToPaisa(assetsInr - liabilitiesInr);
+        const netIncomeAverageInr = roundToPaisa(netIncomeForeign * averageRate);
+        const totalEquityPreFctrInr = roundToPaisa(shareCapitalInr + openingRetainedEarningsInr + netIncomeAverageInr);
+
+        const fctrInr = roundToPaisa(netAssetsClosingInr - totalEquityPreFctrInr);
+        totalFctrReserveInr = roundToPaisa(totalFctrReserveInr + fctrInr);
+
+        return {
+            entityName,
+            closingRate,
+            averageRate,
+            totalAssetsInr: assetsInr,
+            totalLiabilitiesInr: liabilitiesInr,
+            netAssetsClosingInr,
+            netIncomeInr: netIncomeAverageInr,
+            fctrBalanceInr: fctrInr,
+            treatment: 'Translation difference routed to Foreign Currency Translation Reserve (FCTR) in Other Comprehensive Income (OCI) under Ind AS 21.39.'
+        };
+    });
+
+    const totalDebits = roundToPaisa(journalEntries.reduce((acc, e) => acc + e.debitInr, 0));
+    const totalCredits = roundToPaisa(journalEntries.reduce((acc, e) => acc + e.creditInr, 0));
+    const isDoubleEntryBalanced = Math.abs(totalDebits - totalCredits) < 0.001;
+
+    return {
+        status: 'SUCCESS',
+        standard: 'Ind AS 21 / IAS 21 / US GAAP ASC 830',
+        asOfDate,
+        functionalCurrency,
+        totalItemsEvaluated: revaluedItems.length,
+        foreignOperationsCount: translatedOperations.length,
+        summary: {
+            totalOriginalBookValueInr,
+            totalClosingBookValueInr,
+            totalUnrealizedGainInr,
+            totalUnrealizedLossInr,
+            netUnrealizedPnLInr,
+            totalFctrReserveInr,
+            isDoubleEntryBalanced,
+            totalDebitsInr: totalDebits,
+            totalCreditsInr: totalCredits
+        },
+        revaluedItems,
+        translatedForeignOperations: translatedOperations,
+        journalEntries,
+        isAuthorizedToDisburse: false,
+        statutoryRationale: `Ind AS 21 evaluation completed: ${revaluedItems.length} monetary/non-monetary exposures revalued. Net unrealized P&L variance: INR ${netUnrealizedPnLInr.toLocaleString('en-IN')}; Total FCTR in OCI: INR ${totalFctrReserveInr.toLocaleString('en-IN')}. General Ledger vouchers balanced at INR ${totalDebits.toLocaleString('en-IN')}. Foreign currency revaluation does not authorize payment disbursement.`
+    };
+}
+
+/**
+ * Ind AS 36 / IAS 36 / US GAAP ASC 360 & 350: Impairment of Assets & Cash-Generating Units (CGU).
+ */
+export function calculateImpairmentIndAs36(params = {}) {
+    const asOfDate = params.asOfDate || new Date().toISOString().split('T')[0];
+    const cguId = params.cguId || 'CGU-01';
+    const cguName = params.cguName || 'Corporate Cash-Generating Unit';
+
+    const rawAmounts = params.carryingAmounts || {};
+    const goodwill = roundToPaisa(cleanNumericAmount(rawAmounts.goodwill, { defaultValue: 0 }));
+    const ppe = roundToPaisa(cleanNumericAmount(rawAmounts.propertyPlantEquipment, { defaultValue: 0 }));
+    const intangibles = roundToPaisa(cleanNumericAmount(rawAmounts.intangibleAssets, { defaultValue: 0 }));
+    const otherNonCurrent = roundToPaisa(cleanNumericAmount(rawAmounts.otherNonCurrentAssets, { defaultValue: 0 }));
+
+    const totalCarryingAmount = roundToPaisa(goodwill + ppe + intangibles + otherNonCurrent);
+
+    if (totalCarryingAmount <= 0) {
+        return {
+            status: 'INSUFFICIENT_DATA',
+            standard: 'Ind AS 36 / IAS 36 / US GAAP ASC 360',
+            cguId,
+            totalCarryingAmountInr: 0,
+            isAuthorizedToDisburse: false,
+            statutoryRationale: 'Carrying amounts must be greater than zero for impairment evaluation.'
+        };
+    }
+
+    const rad = params.recoverableAmountDetermination || {};
+    const fvlcod = roundToPaisa(cleanNumericAmount(rad.fairValueLessCostsOfDisposal, { defaultValue: 0 }));
+
+    let valueInUse = 0;
+    let discountRate = 0;
+    const discountedCashFlows = [];
+
+    if (rad.valueInUse && typeof rad.valueInUse === 'object') {
+        discountRate = cleanNumericAmount(rad.valueInUse.preTaxDiscountRatePercent, { defaultValue: 10 }) / 100;
+        const cashFlows = Array.isArray(rad.valueInUse.projectedCashFlows) ? rad.valueInUse.projectedCashFlows : [];
+
+        let pvSum = 0;
+        cashFlows.forEach((cfRaw, idx) => {
+            const year = idx + 1;
+            const cf = cleanNumericAmount(cfRaw, { defaultValue: 0 });
+            const discountFactor = 1 / Math.pow(1 + discountRate, year);
+            const presentValue = roundToPaisa(cf * discountFactor);
+            pvSum = roundToPaisa(pvSum + presentValue);
+            discountedCashFlows.push({ year, cashFlow: cf, discountFactor: Number(discountFactor.toFixed(4)), presentValue });
+        });
+
+        let terminalPv = 0;
+        if (rad.valueInUse.terminalValue) {
+            const tv = cleanNumericAmount(rad.valueInUse.terminalValue, { defaultValue: 0 });
+            const finalYear = cashFlows.length || 1;
+            const tvDiscountFactor = 1 / Math.pow(1 + discountRate, finalYear);
+            terminalPv = roundToPaisa(tv * tvDiscountFactor);
+        } else if (rad.valueInUse.terminalGrowthRatePercent && cashFlows.length > 0) {
+            const g = cleanNumericAmount(rad.valueInUse.terminalGrowthRatePercent, { defaultValue: 2 }) / 100;
+            const finalCf = cleanNumericAmount(cashFlows[cashFlows.length - 1], { defaultValue: 0 });
+            if (discountRate > g) {
+                const tv = (finalCf * (1 + g)) / (discountRate - g);
+                const finalYear = cashFlows.length;
+                const tvDiscountFactor = 1 / Math.pow(1 + discountRate, finalYear);
+                terminalPv = roundToPaisa(tv * tvDiscountFactor);
+            }
+        }
+
+        valueInUse = roundToPaisa(pvSum + terminalPv);
+    }
+
+    const recoverableAmount = Math.max(fvlcod, valueInUse);
+    const recoverableMethod = fvlcod >= valueInUse ? 'FAIR_VALUE_LESS_COSTS_OF_DISPOSAL' : 'VALUE_IN_USE';
+
+    let impairmentRequired = false;
+    let totalImpairmentLoss = 0;
+    let postImpairmentCarryingAmount = totalCarryingAmount;
+    let goodwillImpairment = 0;
+    let ppeImpairment = 0;
+    let intangiblesImpairment = 0;
+    let otherImpairment = 0;
+    const journalEntries = [];
+
+    if (recoverableAmount < totalCarryingAmount) {
+        impairmentRequired = true;
+        totalImpairmentLoss = roundToPaisa(totalCarryingAmount - recoverableAmount);
+        postImpairmentCarryingAmount = recoverableAmount;
+
+        let remainingLoss = totalImpairmentLoss;
+        if (goodwill > 0) {
+            goodwillImpairment = Math.min(goodwill, remainingLoss);
+            remainingLoss = roundToPaisa(remainingLoss - goodwillImpairment);
+            journalEntries.push({
+                account: 'Accumulated Impairment - Goodwill',
+                type: 'INTANGIBLE_ASSET_CONTRA',
+                debitInr: 0,
+                creditInr: goodwillImpairment,
+                rule: 'Ind AS 36.104(a) Goodwill Priority Write-Down'
+            });
+        }
+
+        const floors = params.assetFloors || {};
+        const ppeFloor = cleanNumericAmount(floors.propertyPlantEquipment, { defaultValue: 0 });
+        const intFloor = cleanNumericAmount(floors.intangibleAssets, { defaultValue: 0 });
+        const otherFloor = cleanNumericAmount(floors.otherNonCurrentAssets, { defaultValue: 0 });
+
+        const ppeMaxWriteDown = Math.max(0, ppe - ppeFloor);
+        const intMaxWriteDown = Math.max(0, intangibles - intFloor);
+        const otherMaxWriteDown = Math.max(0, otherNonCurrent - otherFloor);
+        const totalEligibleBase = ppeMaxWriteDown + intMaxWriteDown + otherMaxWriteDown;
+
+        if (remainingLoss > 0 && totalEligibleBase > 0) {
+            const ppeRatio = ppeMaxWriteDown / totalEligibleBase;
+            const intRatio = intMaxWriteDown / totalEligibleBase;
+
+            ppeImpairment = roundToPaisa(Math.min(ppeMaxWriteDown, remainingLoss * ppeRatio));
+            intangiblesImpairment = roundToPaisa(Math.min(intMaxWriteDown, remainingLoss * intRatio));
+            otherImpairment = roundToPaisa(remainingLoss - ppeImpairment - intangiblesImpairment);
+
+            if (ppeImpairment > 0) {
+                journalEntries.push({
+                    account: 'Accumulated Impairment - Property, Plant & Equipment',
+                    type: 'PPE_CONTRA',
+                    debitInr: 0,
+                    creditInr: ppeImpairment,
+                    rule: 'Ind AS 36.104(b) Pro-rata PPE Allocation'
+                });
+            }
+            if (intangiblesImpairment > 0) {
+                journalEntries.push({
+                    account: 'Accumulated Impairment - Intangible Assets',
+                    type: 'INTANGIBLE_CONTRA',
+                    debitInr: 0,
+                    creditInr: intangiblesImpairment,
+                    rule: 'Ind AS 36.104(b) Pro-rata Intangibles Allocation'
+                });
+            }
+            if (otherImpairment > 0) {
+                journalEntries.push({
+                    account: 'Accumulated Impairment - Other Non-Current Assets',
+                    type: 'NON_CURRENT_ASSET_CONTRA',
+                    debitInr: 0,
+                    creditInr: otherImpairment,
+                    rule: 'Ind AS 36.104(b) Pro-rata Other Assets Allocation'
+                });
+            }
+        }
+
+        journalEntries.unshift({
+            account: 'Impairment Loss on Assets (Statement of Profit & Loss)',
+            type: 'OPERATING_EXPENSE',
+            debitInr: totalImpairmentLoss,
+            creditInr: 0,
+            rule: 'Ind AS 36.60 Recognition in Profit or Loss'
+        });
+    }
+
+    const totalDebits = roundToPaisa(journalEntries.reduce((acc, e) => acc + e.debitInr, 0));
+    const totalCredits = roundToPaisa(journalEntries.reduce((acc, e) => acc + e.creditInr, 0));
+    const isDoubleEntryBalanced = Math.abs(totalDebits - totalCredits) < 0.001;
+
+    return {
+        status: 'SUCCESS',
+        standard: 'Ind AS 36 / IAS 36 / US GAAP ASC 360',
+        asOfDate,
+        cguId,
+        cguName,
+        valuation: {
+            totalCarryingAmountInr: totalCarryingAmount,
+            fairValueLessCostsOfDisposalInr: fvlcod,
+            valueInUseInr: valueInUse,
+            recoverableAmountInr: recoverableAmount,
+            recoverableMethod,
+            headroomInr: Math.max(0, recoverableAmount - totalCarryingAmount),
+            impairmentRequired,
+            totalImpairmentLossInr: totalImpairmentLoss,
+            postImpairmentCarryingAmountInr: postImpairmentCarryingAmount
+        },
+        assetBreakdown: {
+            goodwill: { initialCarryingInr: goodwill, impairmentInr: goodwillImpairment, closingCarryingInr: roundToPaisa(goodwill - goodwillImpairment) },
+            propertyPlantEquipment: { initialCarryingInr: ppe, impairmentInr: ppeImpairment, closingCarryingInr: roundToPaisa(ppe - ppeImpairment) },
+            intangibleAssets: { initialCarryingInr: intangibles, impairmentInr: intangiblesImpairment, closingCarryingInr: roundToPaisa(intangibles - intangiblesImpairment) },
+            otherNonCurrentAssets: { initialCarryingInr: otherNonCurrent, impairmentInr: otherImpairment, closingCarryingInr: roundToPaisa(otherNonCurrent - otherImpairment) }
+        },
+        discountedCashFlowsSchedule: discountedCashFlows,
+        journalEntries,
+        isDoubleEntryBalanced,
+        isAuthorizedToDisburse: false,
+        statutoryRationale: impairmentRequired
+            ? `Ind AS 36 Impairment Test: CGU "${cguName}" carrying value INR ${totalCarryingAmount.toLocaleString('en-IN')} exceeds recoverable amount INR ${recoverableAmount.toLocaleString('en-IN')} (${recoverableMethod}). Impairment loss of INR ${totalImpairmentLoss.toLocaleString('en-IN')} recognized in P&L. Goodwill reduced by INR ${goodwillImpairment.toLocaleString('en-IN')}; non-current assets reduced pro-rata by INR ${(totalImpairmentLoss - goodwillImpairment).toLocaleString('en-IN')}. Impairment assessment does not authorize payment disbursement.`
+            : `Ind AS 36 Impairment Test: CGU "${cguName}" carrying value INR ${totalCarryingAmount.toLocaleString('en-IN')} is fully supported by recoverable amount INR ${recoverableAmount.toLocaleString('en-IN')} (${recoverableMethod}) with headroom of INR ${(recoverableAmount - totalCarryingAmount).toLocaleString('en-IN')}. No impairment recognized. Impairment assessment does not authorize payment disbursement.`
+    };
+}
+
+
 // ===========================================================================
 // COMMERCIAL TIER BOUNDARY SPECIFICATION (OKF v0.2 / ENTERPRISE BOUNDARY)
 // ===========================================================================