@trajectonomics/tax 0.0.0-stage → 0.1.0-alpha.0

package/dist/th/index.cjs

@@ -0,0 +1,1480 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_clamp = require("../clamp-BKG7kjVf.cjs");
+// src/th/parameters-brackets.ts
+/**
+* Section 48(1) progressive net-income brackets for Tax Year 2026 (THB major units, rates as ratios).
+*
+* @statute Thailand Revenue Code Section 48(1); Royal Decree No. 650.
+*/
+const TH_2026_BRACKETS = [
+	{
+		upTo: 15e4,
+		rate: 0
+	},
+	{
+		upTo: 3e5,
+		rate: .05
+	},
+	{
+		upTo: 5e5,
+		rate: .1
+	},
+	{
+		upTo: 75e4,
+		rate: .15
+	},
+	{
+		upTo: 1e6,
+		rate: .2
+	},
+	{
+		upTo: 2e6,
+		rate: .25
+	},
+	{
+		upTo: 5e6,
+		rate: .3
+	},
+	{
+		upTo: null,
+		rate: .35
+	}
+];
+// src/th/parameters-special.ts
+/**
+* Section 40(4) final withholding rates for Tax Year 2026.
+*
+* @statute Thailand Revenue Code Sections 40(4), 50(2)(g), 57 ter.
+*/
+const TH_2026_FINAL_WITHHOLDING = {
+	interestRate: .15,
+	dividendRate: .1,
+	digitalAssetRate: .15
+};
+/**
+* Section 48(5) separate sheet parameters for Tax Year 2026: exemption, expenses, and schedule.
+* The schedule is the Section 48(1) ladder without its 0% tier (same upper bounds and rates).
+*
+* @statute Thailand Revenue Code Section 48(5), Section 42(1).
+*/
+const TH_2026_SEPARATE_SHEET = {
+	minYearsOfService: 5,
+	exemptionWageDays: 400,
+	exemptionCeiling: 6e5,
+	expensePerYearOfService: 7e3,
+	remainderExpenseRate: .5,
+	brackets: TH_2026_BRACKETS.filter((bracket) => bracket.rate > 0)
+};
+// src/th/parameters.ts
+/**
+* Thailand Statutory Tax Parameters for Tax Year 2026 (Revenue Code ภ.ง.ด.90/91).
+*
+* @statute Thailand Revenue Code Sections 40, 42 bis, 47, 47 bis, 48(1)–(5); Royal Decrees No. 11, 650.
+*/
+const TH_2026_PARAMETERS = {
+	taxYear: 2026,
+	currency: "THB",
+	expenses: {
+		section40_1_2: {
+			rate: .5,
+			ceiling: 1e5
+		},
+		section40_3: {
+			rate: .5,
+			ceiling: 1e5
+		},
+		section40_4: { rate: 0 },
+		section40_5: {
+			building: .3,
+			agriculturalLand: .2,
+			nonAgriculturalLand: .15,
+			vehicles: .3,
+			other: .1
+		},
+		section40_6: {
+			medical: .6,
+			other: .3
+		},
+		section40_7: { rate: .6 },
+		section40_8: {
+			generalRate: .6,
+			entertainerFirstTierRate: .6,
+			entertainerFirstTierThreshold: 3e5,
+			entertainerSecondTierRate: .4,
+			entertainerCeiling: 6e5
+		}
+	},
+	allowances: {
+		personal: 6e4,
+		spouse: 6e4,
+		child: {
+			basePerChild: 3e4,
+			bonusSecondPlusBorn2018OrLater: 3e4,
+			bonusCutoffYear: 2018
+		},
+		parent: {
+			perPerson: 3e4,
+			maxCount: 4
+		},
+		disabledPerPerson: 6e4,
+		socialSecurityFundCeiling: 10500,
+		lifeInsurance: {
+			combinedCeiling: 1e5,
+			healthCeiling: 25e3
+		},
+		parentHealthInsuranceCeiling: 15e3,
+		spouseLifeInsuranceCeiling: 1e4,
+		mortgageInterestCeiling: 1e5,
+		retirementCluster: {
+			combinedCeiling: 5e5,
+			rmf: {
+				maxRate: .3,
+				ceiling: 5e5
+			},
+			ssf: {
+				maxRate: .3,
+				ceiling: 2e5
+			},
+			pvd: {
+				maxRate: .15,
+				ceiling: 5e5
+			},
+			gpf: {
+				maxRate: .3,
+				ceiling: 5e5
+			},
+			nsf: { ceiling: 3e4 },
+			pensionLifeInsurance: {
+				maxRate: .15,
+				ceiling: 2e5
+			}
+		},
+		thaiEsg: {
+			maxRate: .3,
+			ceiling: 3e5
+		},
+		donations: {
+			donation2xMultiplier: 2,
+			donation2xMaxRate: .1,
+			donation1xMaxRate: .1
+		}
+	},
+	brackets: TH_2026_BRACKETS,
+	minimumGrossTax: {
+		rate: .005,
+		incomeThreshold: 12e4,
+		taxThreshold: 5e3
+	},
+	finalWithholding: TH_2026_FINAL_WITHHOLDING,
+	separateSheet: TH_2026_SEPARATE_SHEET,
+	realEstate: {
+		expenseTable: [
+			{
+				minYears: 1,
+				rate: .92
+			},
+			{
+				minYears: 2,
+				rate: .84
+			},
+			{
+				minYears: 3,
+				rate: .77
+			},
+			{
+				minYears: 4,
+				rate: .71
+			},
+			{
+				minYears: 5,
+				rate: .65
+			},
+			{
+				minYears: 6,
+				rate: .6
+			},
+			{
+				minYears: 7,
+				rate: .55
+			},
+			{
+				minYears: 8,
+				rate: .5
+			}
+		],
+		inheritanceExpenseRate: .5,
+		maxHoldingYears: 10,
+		brackets: TH_2026_SEPARATE_SHEET.brackets,
+		taxCapRate: .2
+	}
+};
+// src/th/types/special-input.ts
+/**
+* Election values for a Section 40(4) source: keep source withholding as final tax, or include
+* the income in the regular progressive computation. Plain `"final"`/`"include"` strings are
+* accepted wherever {@link ThFinalWithholdingElection} is expected.
+*
+* @statute Thailand Revenue Code Sections 40(4), 50(2)(g), 57 ter.
+*/
+const ThFinalWithholdingElection = {
+	Final: "final",
+	Include: "include"
+};
+/**
+* Kind of Section 48(5) lump sum. Only labour-law `"severance"` carries the 400-day / 600,000 THB
+* exemption; other `"retirement"` payments (e.g. a pension fund lump sum) get none.
+* Plain `"severance"`/`"retirement"` strings are accepted wherever
+* {@link ThSeparateSheetPaymentType} is expected.
+*
+* @statute Thailand Revenue Code Section 48(5); Section 42(1) (severance exemption).
+*/
+const ThSeparateSheetPaymentType = {
+	Severance: "severance",
+	Retirement: "retirement"
+};
+/**
+* How a Section 48(4) property was acquired. Inherited or gifted property takes a flat 50%
+* expense; commercially acquired (or other) property takes the holding-year table. The two are
+* never combined. Plain `"commercial"`/`"inheritance_or_gift"` strings are accepted wherever
+* {@link ThRealEstateAcquisitionType} is expected.
+*
+* @statute Thailand Revenue Code Section 48(4); Ministerial Regulation No. 126.
+*/
+const ThRealEstateAcquisitionType = {
+	Commercial: "commercial",
+	InheritanceOrGift: "inheritance_or_gift"
+};
+/**
+* Which expense deduction a Section 48(4) computation used, reported in the breakdown.
+*
+* @statute Thailand Revenue Code Section 48(4); Ministerial Regulation No. 126.
+*/
+const ThRealEstateExpenseBasis = {
+	HoldingPeriodTable: "holding_period_table",
+	FlatInheritance: "flat_inheritance"
+};
+// src/th/units.ts
+/**
+* Converts a THB major-unit amount to integer satang.
+*
+* Purpose: Single THB-bound entry point so stages never repeat the currency threading.
+* Math: Decimal-exact conversion via `toMinorUnits` (half away from zero beyond 2 decimals).
+* Units: THB major units in, integer satang out.
+* Throws: TaxValidationError if the amount is negative (unless allowed), non-finite, or unsafe.
+*
+* @param amount Amount in THB.
+* @param field Diagnostic field name reported on failure.
+* @statute Thailand Revenue Code Section 40 (amounts expressed in baht).
+*/
+function toSatang(amount, field) {
+	return require_clamp.toMinorUnits(amount, TH_2026_PARAMETERS.currency, field);
+}
+/**
+* Converts integer satang back to THB major units.
+*
+* Purpose: Counterpart of {@link toSatang}.
+* Math: `satang / 100`, fixed to two decimals.
+* Units: Integer satang in, THB major units out.
+* Throws: TaxValidationError if the input is not a safe integer (or is negative without
+* `allowNegative`).
+*
+* @param satang Integer satang.
+* @param field Diagnostic field name reported on failure.
+* @param options Set `allowNegative` for refund balances.
+* @statute Thailand Revenue Code Section 40 (amounts expressed in baht).
+*/
+function fromSatang(satang, field, options) {
+	return require_clamp.fromMinorUnits(satang, TH_2026_PARAMETERS.currency, field, options);
+}
+/**
+* Sums non-negative THB amounts exactly in integer satang.
+*
+* Purpose: Avoids binary float drift when aggregating gross amounts.
+* Math: Converts each amount to satang, adds, converts back to major units.
+* Units: THB major units in and out.
+* Throws: TaxValidationError if any amount is negative or non-finite, or the sum is not a safe integer.
+*
+* @param values Amounts in THB.
+* @param field Diagnostic field name reported on failure.
+* @statute Thailand Revenue Code Section 40 (gross income aggregation).
+*/
+function sumThAmounts(values, field) {
+	return fromSatang(values.reduce((sum, value) => sum + toSatang(value, field), 0), field);
+}
+// src/th/stages/allowances-donations.ts
+/**
+* Calculates qualified 2x and general 1x donation allowances.
+*
+* Math: 2x donations capped at 10% of net before donations; 1x donations capped at 10% of remaining net.
+* Units: THB major units.
+*
+* @statute Thailand Revenue Code Section 47(7); Royal Decrees No. 428, 558.
+*/
+function calculateDonationAllowances(donation2x, donation1x, netBeforeDonations) {
+	const p = TH_2026_PARAMETERS.allowances.donations;
+	const net = Math.max(0, netBeforeDonations);
+	const raw2x = donation2x ?? 0;
+	require_clamp.validateMonetaryAmount(raw2x, "allowance.donation_2x");
+	const eligible2x = raw2x * p.donation2xMultiplier;
+	const cap2x = Math.floor(net * p.donation2xMaxRate);
+	const allowed2x = Math.min(eligible2x, cap2x);
+	const clamped2x = {
+		requested: raw2x,
+		allowed: allowed2x,
+		cap: cap2x,
+		wasClamped: eligible2x > cap2x
+	};
+	const remainingNet = Math.max(0, net - allowed2x);
+	const raw1x = donation1x ?? 0;
+	require_clamp.validateMonetaryAmount(raw1x, "allowance.donation_1x");
+	const cap1x = Math.floor(remainingNet * p.donation1xMaxRate);
+	const allowed1x = Math.min(raw1x, cap1x);
+	const breakdown = {
+		donation2x: clamped2x,
+		donation1x: {
+			requested: raw1x,
+			allowed: allowed1x,
+			cap: cap1x,
+			wasClamped: raw1x > cap1x
+		},
+		total: allowed2x + allowed1x
+	};
+	const netTaxableIncome = Math.max(0, remainingNet - allowed1x);
+	return {
+		breakdown,
+		allowedDonationsTotal: breakdown.total,
+		netTaxableIncome
+	};
+}
+// src/th/stages/allowances-family.ts
+const unclamped = (n) => ({
+	requested: n,
+	allowed: n,
+	cap: n,
+	wasClamped: false
+});
+function countBonusChildren(children, cutoff) {
+	const sorted = [...children].sort((a, b) => (a.birthYear ?? 0) - (b.birthYear ?? 0));
+	let bonus = 0;
+	for (let i = 1; i < sorted.length; i++) if ((sorted[i]?.birthYear ?? 0) >= cutoff) bonus++;
+	return bonus;
+}
+function computeChildAllowance(children) {
+	if (!children) return unclamped(0);
+	const p = TH_2026_PARAMETERS.allowances.child;
+	if (Array.isArray(children)) {
+		const bonus = countBonusChildren(children, p.bonusCutoffYear);
+		return unclamped(children.length * p.basePerChild + bonus * p.bonusSecondPlusBorn2018OrLater);
+	}
+	const counts = children;
+	require_clamp.validateMonetaryAmount(counts.totalCount ?? 0, "allowance.children");
+	const count = Math.max(0, Math.floor(counts.totalCount ?? 0));
+	const bonusReq = Math.max(0, Math.floor(counts.secondPlusBorn2018OrLaterCount ?? 0));
+	const bonus = Math.min(bonusReq, Math.max(0, count - 1));
+	return unclamped(count * p.basePerChild + bonus * p.bonusSecondPlusBorn2018OrLater);
+}
+function computeParentCount(parents, status) {
+	if (parents === void 0) return 0;
+	if (typeof parents === "number") {
+		require_clamp.validateMonetaryAmount(parents, "allowance.parents");
+		return Math.floor(parents);
+	}
+	let count = (parents.taxpayerFather ? 1 : 0) + (parents.taxpayerMother ? 1 : 0);
+	if (status === "married_no_income_spouse") count += (parents.spouseFather ? 1 : 0) + (parents.spouseMother ? 1 : 0);
+	return count;
+}
+/**
+* Calculates family allowances (personal, spouse, children, parents, disabled).
+*
+* @statute Thailand Revenue Code Section 47(1)(a)–(f).
+*/
+function calculateFamilyAllowances(input = {}, filingStatus = "single") {
+	const p = TH_2026_PARAMETERS.allowances;
+	const personalReq = input.personal ?? p.personal;
+	const personal = require_clamp.clampCap(personalReq, p.personal, "allowance.personal");
+	const isSpouseEligible = filingStatus === "married_no_income_spouse" || filingStatus === "married_joint";
+	const spouseRequested = input.spouse ?? (isSpouseEligible ? p.spouse : 0);
+	const spouse = isSpouseEligible ? require_clamp.clampCap(spouseRequested, p.spouse, "allowance.spouse") : {
+		requested: spouseRequested,
+		allowed: 0,
+		cap: 0,
+		wasClamped: spouseRequested > 0
+	};
+	const children = computeChildAllowance(input.children);
+	const parentsRequested = computeParentCount(input.parents, filingStatus) * p.parent.perPerson;
+	const parents = require_clamp.clampCap(parentsRequested, p.parent.perPerson * p.parent.maxCount, "allowance.parents");
+	const disabledRequested = (input.disabledCareCount ?? 0) * p.disabledPerPerson;
+	require_clamp.validateMonetaryAmount(disabledRequested, "allowance.disabled");
+	return {
+		personal,
+		spouse,
+		children,
+		parents,
+		disabled: unclamped(disabledRequested)
+	};
+}
+// src/th/stages/allowances-insurance.ts
+/**
+* Calculates insurance, social security, and housing mortgage interest allowances.
+*
+* @statute Thailand Revenue Code Section 47(1)(d), (g), (h), (j).
+*/
+function calculateInsuranceAllowances(input = {}, filingStatus = "single") {
+	const p = TH_2026_PARAMETERS.allowances;
+	const socialSecurity = require_clamp.clampCap(input.socialSecurity ?? 0, p.socialSecurityFundCeiling, "allowance.social_security");
+	const healthClamped = require_clamp.clampCap(input.healthInsurance ?? 0, p.lifeInsurance.healthCeiling, "allowance.health_insurance");
+	const rawLife = input.lifeInsurance ?? 0;
+	if (input.lifeInsurance !== void 0) require_clamp.validateMonetaryAmount(rawLife, "allowance.life_health_combined");
+	const lifeCombinedRequested = rawLife + (input.healthInsurance ?? 0);
+	const lifeEffectiveRequested = rawLife + healthClamped.allowed;
+	const lifeCombined = require_clamp.clampCap(lifeEffectiveRequested, p.lifeInsurance.combinedCeiling, "allowance.life_health_combined");
+	const lifeInsurance = {
+		requested: lifeCombinedRequested,
+		allowed: lifeCombined.allowed,
+		cap: p.lifeInsurance.combinedCeiling,
+		wasClamped: lifeCombinedRequested > lifeCombined.allowed
+	};
+	const parentHealthInsurance = require_clamp.clampCap(input.parentHealthInsurance ?? 0, p.parentHealthInsuranceCeiling, "allowance.parent_health_insurance");
+	const isSpouseEligible = filingStatus === "married_no_income_spouse";
+	const spouseLifeReq = input.spouseLifeInsurance ?? 0;
+	return {
+		socialSecurity,
+		lifeInsurance,
+		parentHealthInsurance,
+		spouseLifeInsurance: isSpouseEligible ? require_clamp.clampCap(spouseLifeReq, p.spouseLifeInsuranceCeiling, "allowance.spouse_life_insurance") : {
+			requested: spouseLifeReq,
+			allowed: 0,
+			cap: 0,
+			wasClamped: spouseLifeReq > 0
+		},
+		mortgageInterest: require_clamp.clampCap(input.mortgageInterest ?? 0, p.mortgageInterestCeiling, "allowance.mortgage_interest")
+	};
+}
+// src/th/stages/allowances-retirement.ts
+/**
+* Calculates Retirement Cluster and ThaiESG allowances.
+*
+* @statute Thailand Revenue Code Section 47; Ministerial Regulations No. 126, 390.
+*/
+function calculateRetirementAllowances(input = {}, assessableIncome, wageBase) {
+	const p = TH_2026_PARAMETERS.allowances.retirementCluster;
+	const currency = TH_2026_PARAMETERS.currency;
+	const wage = Math.max(wageBase, 0);
+	const rmf = require_clamp.clampCap(input.rmf ?? 0, {
+		base: assessableIncome,
+		rate: p.rmf.maxRate,
+		ceiling: p.rmf.ceiling,
+		currency
+	}, "allowance.retirement.rmf");
+	const ssf = require_clamp.clampCap(input.ssf ?? 0, {
+		base: assessableIncome,
+		rate: p.ssf.maxRate,
+		ceiling: p.ssf.ceiling,
+		currency
+	}, "allowance.retirement.ssf");
+	const pvd = require_clamp.clampCap(input.pvd ?? 0, {
+		base: wage,
+		rate: p.pvd.maxRate,
+		ceiling: p.pvd.ceiling,
+		currency
+	}, "allowance.retirement.pvd");
+	const gpf = require_clamp.clampCap(input.gpf ?? 0, {
+		base: wage,
+		rate: p.gpf.maxRate,
+		ceiling: p.gpf.ceiling,
+		currency
+	}, "allowance.retirement.gpf");
+	const nsf = require_clamp.clampCap(input.nsf ?? 0, p.nsf.ceiling, "allowance.retirement.nsf");
+	const pensionLifeInsurance = require_clamp.clampCap(input.pensionLifeInsurance ?? 0, {
+		base: assessableIncome,
+		rate: p.pensionLifeInsurance.maxRate,
+		ceiling: p.pensionLifeInsurance.ceiling,
+		currency
+	}, "allowance.retirement.pension_life");
+	const individualSum = rmf.allowed + ssf.allowed + pvd.allowed + gpf.allowed + nsf.allowed + pensionLifeInsurance.allowed;
+	const combined = require_clamp.clampCap(individualSum, p.combinedCeiling, "allowance.retirement_cluster");
+	const retirementCluster = {
+		rmf,
+		ssf,
+		pvd,
+		gpf,
+		nsf,
+		pensionLifeInsurance,
+		combined
+	};
+	const thaiEsgParam = TH_2026_PARAMETERS.allowances.thaiEsg;
+	const thaiEsg = require_clamp.clampCap(input.thaiEsg ?? 0, {
+		base: assessableIncome,
+		rate: thaiEsgParam.maxRate,
+		ceiling: thaiEsgParam.ceiling,
+		currency
+	}, "allowance.thai_esg");
+	return {
+		retirementCluster,
+		thaiEsg,
+		allowedClusterTotal: combined.allowed,
+		allowedThaiEsgTotal: thaiEsg.allowed
+	};
+}
+// src/th/stages/allowances.ts
+/**
+* Aggregates all personal, family, insurance, retirement, and donation allowances.
+*
+* @statute Thailand Revenue Code Section 47.
+*/
+function calculateAllowances(input = {}, filingStatus = "single", assessableTotal, expensesTotal, wageBase) {
+	const fam = calculateFamilyAllowances(input, filingStatus);
+	const ins = calculateInsuranceAllowances(input, filingStatus);
+	const ret = calculateRetirementAllowances(input, assessableTotal, wageBase);
+	const nonDonationTotal = fam.personal.allowed + fam.spouse.allowed + fam.children.allowed + fam.parents.allowed + fam.disabled.allowed + ins.socialSecurity.allowed + ins.lifeInsurance.allowed + ins.parentHealthInsurance.allowed + ins.spouseLifeInsurance.allowed + ins.mortgageInterest.allowed + ret.allowedClusterTotal + ret.allowedThaiEsgTotal;
+	const netBeforeDonations = Math.max(0, assessableTotal - expensesTotal - nonDonationTotal);
+	const don = calculateDonationAllowances(input.donation2x, input.donation1x, netBeforeDonations);
+	const total = nonDonationTotal + don.allowedDonationsTotal;
+	return {
+		breakdown: {
+			personal: fam.personal,
+			spouse: fam.spouse,
+			children: fam.children,
+			parents: fam.parents,
+			disabled: fam.disabled,
+			socialSecurity: ins.socialSecurity,
+			lifeInsurance: ins.lifeInsurance,
+			parentHealthInsurance: ins.parentHealthInsurance,
+			spouseLifeInsurance: ins.spouseLifeInsurance,
+			mortgageInterest: ins.mortgageInterest,
+			retirementCluster: ret.retirementCluster,
+			thaiEsg: ret.thaiEsg,
+			donations: don.breakdown,
+			total
+		},
+		netTaxableIncome: don.netTaxableIncome
+	};
+}
+// src/th/stages/assessable.ts
+function extractElectableAmount(val, field) {
+	if (val === void 0) return 0;
+	const amount = typeof val === "number" ? val : val.amount;
+	require_clamp.validateMonetaryAmount(amount, field);
+	if (typeof val === "object" && val.actualExpense !== void 0) require_clamp.validateMonetaryAmount(val.actualExpense, `${field}.actualExpense`);
+	return amount;
+}
+function sumSection40_5(input) {
+	if (!input) return 0;
+	return extractElectableAmount(input.building, "income.section40_5.building") + extractElectableAmount(input.agriculturalLand, "income.section40_5.agriculturalLand") + extractElectableAmount(input.nonAgriculturalLand, "income.section40_5.nonAgriculturalLand") + extractElectableAmount(input.vehicles, "income.section40_5.vehicles") + extractElectableAmount(input.other, "income.section40_5.other");
+}
+function sumSection40_6(input) {
+	if (!input) return 0;
+	return extractElectableAmount(input.medical, "income.section40_6.medical") + extractElectableAmount(input.law, "income.section40_6.law") + extractElectableAmount(input.engineering, "income.section40_6.engineering") + extractElectableAmount(input.architecture, "income.section40_6.architecture") + extractElectableAmount(input.accounting, "income.section40_6.accounting") + extractElectableAmount(input.fineArts, "income.section40_6.fineArts") + extractElectableAmount(input.other, "income.section40_6.other");
+}
+function sumSection40_8(input) {
+	if (input === void 0) return 0;
+	if (typeof input === "number" || "amount" in input) return extractElectableAmount(input, "income.section40_8");
+	return extractElectableAmount(input.general, "income.section40_8.general") + extractElectableAmount(input.entertainer, "income.section40_8.entertainer");
+}
+/**
+* Normalizes and validates assessable income across Section 40(1)–40(8).
+*
+* @statute Thailand Revenue Code Section 40(1)–(8).
+*/
+function calculateAssessableIncome(input = {}) {
+	const s1 = extractElectableAmount(input.section40_1, "income.section40_1");
+	const s2 = extractElectableAmount(input.section40_2, "income.section40_2");
+	const s3 = extractElectableAmount(input.section40_3, "income.section40_3");
+	const s4 = extractElectableAmount(typeof input.section40_4 === "number" ? input.section40_4 : input.section40_4?.amount, "income.section40_4");
+	const s5 = sumSection40_5(input.section40_5);
+	const s6 = sumSection40_6(input.section40_6);
+	const s7 = extractElectableAmount(input.section40_7, "income.section40_7");
+	const s8 = sumSection40_8(input.section40_8);
+	return {
+		section40_1: s1,
+		section40_2: s2,
+		section40_3: s3,
+		section40_4: s4,
+		section40_5: s5,
+		section40_6: s6,
+		section40_7: s7,
+		section40_8: s8,
+		total: s1 + s2 + s3 + s4 + s5 + s6 + s7 + s8,
+		grossNonEmploymentIncome: s2 + s3 + s4 + s5 + s6 + s7 + s8
+	};
+}
+// src/th/stages/bracket-eval.ts
+/**
+* Evaluates an arbitrary Thai statutory bracket schedule (major-unit bounds) in minor units.
+*
+* Math: Converts bounds and incomes to satang, slices through `evaluateBrackets`, converts back.
+* Units: Inputs and outputs in THB major units; arithmetic in integer satang.
+* Throws: TaxValidationError if incomes are negative or non-finite.
+*
+* @statute Thailand Revenue Code Sections 48(1), 48(4), 48(5).
+*/
+function evaluateThBracketSet(taxableIncome, grossIncome, brackets) {
+	const currency = TH_2026_PARAMETERS.currency;
+	const minorBrackets = brackets.map((b) => ({
+		upTo: b.upTo === null ? null : require_clamp.toMinorUnits(b.upTo, currency),
+		rate: b.rate
+	}));
+	const taxableMinor = require_clamp.toMinorUnits(taxableIncome, currency, "taxableIncome");
+	const grossMinor = require_clamp.toMinorUnits(grossIncome, currency, "grossIncome");
+	const res = require_clamp.evaluateBrackets(taxableMinor, minorBrackets, grossMinor);
+	const slices = res.slices.map((s) => ({
+		bracketIndex: s.bracketIndex,
+		lowerBound: require_clamp.fromMinorUnits(s.lowerBound, currency),
+		upperBound: s.upperBound !== null ? require_clamp.fromMinorUnits(s.upperBound, currency) : null,
+		rate: s.rate,
+		taxableAmount: require_clamp.fromMinorUnits(s.taxableAmount, currency),
+		tax: require_clamp.fromMinorUnits(s.tax, currency)
+	}));
+	const totalTax = require_clamp.fromMinorUnits(res.totalTax, currency);
+	return {
+		totalTax,
+		brackets: {
+			totalTax,
+			slices,
+			effectiveRate: res.effectiveRate,
+			marginalRate: res.marginalRate
+		}
+	};
+}
+/**
+* Evaluates the regular progressive tax brackets for Thailand PIT.
+*
+* Math: Slices taxable income through `TH_2026_PARAMETERS.brackets`.
+* Units: THB major units.
+* Throws: TaxValidationError if incomes are negative or non-finite.
+*
+* @statute Thailand Revenue Code Section 48(1).
+*/
+function evaluateThBrackets(taxableIncome, grossIncome) {
+	return evaluateThBracketSet(taxableIncome, grossIncome, TH_2026_PARAMETERS.brackets);
+}
+// src/th/stages/combine.ts
+/**
+* Combines regular, separate sheet, real estate, and final withholding taxes into one liability.
+*
+* Purpose: Produces the single audited total and the amount still payable (or refundable).
+* Math: totalCombinedTax = regular + separate sheet + real estate + final withholding (before credits);
+* netTaxPayable = totalCombinedTax - final withholding (already withheld at source)
+* - Section 47 bis dividend credit - withholding tax paid. May be negative (refund).
+* Units: Inputs and outputs in THB major units; arithmetic in integer satang.
+* Throws: TaxValidationError if any component is negative or non-finite.
+*
+* @param input Component taxes, credits, and payments in THB.
+* @statute Thailand Revenue Code Sections 40(4), 47 bis, 48(1)–(5).
+*/
+function combineThLiability(input) {
+	const regular = toSatang(input.regularTax, "regularTax");
+	const separateSheet = toSatang(input.separateSheetTax, "separateSheetTax");
+	const realEstate = toSatang(input.realEstateTax, "realEstateTax");
+	const finalWithholding = toSatang(input.finalWithholdingTax, "finalWithholdingTax");
+	const dividendCredit = toSatang(input.dividendTaxCredit, "dividendTaxCredit");
+	const withheld = toSatang(input.withholdingTax, "withholdingTax");
+	const total = regular + separateSheet + realEstate + finalWithholding;
+	const credits = finalWithholding + dividendCredit + withheld;
+	return {
+		totalCombinedTax: fromSatang(total, "totalTax"),
+		netTaxPayable: fromSatang(total - credits, "netTaxPayable", { allowNegative: true })
+	};
+}
+// src/th/stages/expenses-40-1-2.ts
+/**
+* Calculates shared Section 40(1) and Section 40(2) expense deduction.
+*
+* Math: 50% of combined 40(1) + 40(2) income, clamped to 100,000 THB ceiling.
+* Units: THB major units.
+*
+* @statute Thailand Revenue Code Section 42 bis.
+*/
+function calculateExpenses40_1_2(s1, s2) {
+	const combined = s1 + s2;
+	const requested = Math.floor(combined * TH_2026_PARAMETERS.expenses.section40_1_2.rate);
+	return require_clamp.clampCap(requested, TH_2026_PARAMETERS.expenses.section40_1_2.ceiling, "expense.40_1_2");
+}
+// src/th/stages/expenses-40-3.ts
+/**
+* Calculates Section 40(3) royalties/goodwill/copyright expense deduction.
+*
+* Math: Standard 50% capped at 100,000 THB or actual expenses capped at income.
+* Units: THB major units.
+*
+* @statute Thailand Revenue Code Section 42 ter; Royal Decree No. 11 Section 4.
+*/
+function calculateExpenses40_3(input, incomeAmount) {
+	if (incomeAmount <= 0) return {
+		requested: 0,
+		allowed: 0,
+		cap: 0,
+		wasClamped: false
+	};
+	if (typeof input === "object" && input.expenseElection === "actual") {
+		const requested = input.actualExpense ?? 0;
+		return require_clamp.clampCap(requested, incomeAmount, "expense.40_3");
+	}
+	const requested = Math.floor(incomeAmount * TH_2026_PARAMETERS.expenses.section40_3.rate);
+	return require_clamp.clampCap(requested, TH_2026_PARAMETERS.expenses.section40_3.ceiling, "expense.40_3");
+}
+// src/th/stages/expenses-40-4.ts
+/**
+* Calculates Section 40(4) expense deduction (0% statutory).
+*
+* Math: Thailand Revenue Code permits 0% expense deductions for interest, dividends, crypto.
+* Units: THB major units.
+*
+* @statute Thailand Revenue Code Section 40(4).
+*/
+function calculateExpenses40_4(_incomeAmount) {
+	return {
+		requested: 0,
+		allowed: 0,
+		cap: 0,
+		wasClamped: false
+	};
+}
+// src/th/stages/electable-expense.ts
+/**
+* Computes expense deduction for an electable income item (standard % vs actual).
+*
+* Math: If actual, clamp to item income. If standard, apply percentage of item income.
+* Units: THB major units.
+*
+* @param item Income item number or configuration object.
+* @param standardRate Statutory percentage rate for standard deduction.
+* @param field Diagnostic field name.
+*/
+function calculateElectableItemExpense(item, standardRate, field) {
+	if (!item) return {
+		requested: 0,
+		allowed: 0,
+		cap: 0,
+		wasClamped: false
+	};
+	const amount = typeof item === "number" ? item : item.amount;
+	if (amount <= 0) return {
+		requested: 0,
+		allowed: 0,
+		cap: 0,
+		wasClamped: false
+	};
+	if (typeof item === "object" && item.expenseElection === "actual") {
+		const req = item.actualExpense ?? 0;
+		return require_clamp.clampCap(req, amount, field);
+	}
+	const req = Math.floor(amount * standardRate);
+	return {
+		requested: req,
+		allowed: req,
+		cap: amount,
+		wasClamped: false
+	};
+}
+// src/th/stages/expenses-40-5.ts
+/**
+* Calculates Section 40(5) rental expense deductions across property sub-categories.
+*
+* Math: Standard percentage per property class or actual expenses capped at income.
+* Units: THB major units.
+*
+* @statute Thailand Royal Decree No. 11 Section 5.
+*/
+function calculateExpenses40_5(input) {
+	if (!input) return {
+		requested: 0,
+		allowed: 0,
+		cap: 0,
+		wasClamped: false
+	};
+	const rates = TH_2026_PARAMETERS.expenses.section40_5;
+	const b = calculateElectableItemExpense(input.building, rates.building, "expense.40_5.building");
+	const a = calculateElectableItemExpense(input.agriculturalLand, rates.agriculturalLand, "expense.40_5.agri");
+	const na = calculateElectableItemExpense(input.nonAgriculturalLand, rates.nonAgriculturalLand, "expense.40_5.nonAgri");
+	const v = calculateElectableItemExpense(input.vehicles, rates.vehicles, "expense.40_5.vehicles");
+	const o = calculateElectableItemExpense(input.other, rates.other, "expense.40_5.other");
+	const requested = b.requested + a.requested + na.requested + v.requested + o.requested;
+	const allowed = b.allowed + a.allowed + na.allowed + v.allowed + o.allowed;
+	return {
+		requested,
+		allowed,
+		cap: b.cap + a.cap + na.cap + v.cap + o.cap,
+		wasClamped: requested > allowed
+	};
+}
+// src/th/stages/expenses-40-6.ts
+/**
+* Calculates Section 40(6) liberal professions expense deduction.
+*
+* Math: Medical 60%, law/engineering/architecture/accounting/fine arts/other 30%, or actual.
+* Units: THB major units.
+*
+* @statute Thailand Royal Decree No. 11 Section 6.
+*/
+function calculateExpenses40_6(input) {
+	if (!input) return {
+		requested: 0,
+		allowed: 0,
+		cap: 0,
+		wasClamped: false
+	};
+	const rates = TH_2026_PARAMETERS.expenses.section40_6;
+	const med = calculateElectableItemExpense(input.medical, rates.medical, "expense.40_6.medical");
+	const law = calculateElectableItemExpense(input.law, rates.other, "expense.40_6.law");
+	const eng = calculateElectableItemExpense(input.engineering, rates.other, "expense.40_6.eng");
+	const arch = calculateElectableItemExpense(input.architecture, rates.other, "expense.40_6.arch");
+	const acc = calculateElectableItemExpense(input.accounting, rates.other, "expense.40_6.acc");
+	const art = calculateElectableItemExpense(input.fineArts, rates.other, "expense.40_6.art");
+	const oth = calculateElectableItemExpense(input.other, rates.other, "expense.40_6.other");
+	const requested = med.requested + law.requested + eng.requested + arch.requested + acc.requested + art.requested + oth.requested;
+	const allowed = med.allowed + law.allowed + eng.allowed + arch.allowed + acc.allowed + art.allowed + oth.allowed;
+	return {
+		requested,
+		allowed,
+		cap: med.cap + law.cap + eng.cap + arch.cap + acc.cap + art.cap + oth.cap,
+		wasClamped: requested > allowed
+	};
+}
+// src/th/stages/expenses-40-7.ts
+/**
+* Calculates Section 40(7) contracting expense deduction.
+*
+* Math: Standard 60% or actual expenses capped at income.
+* Units: THB major units.
+*
+* @statute Thailand Royal Decree No. 11 Section 7.
+*/
+function calculateExpenses40_7(input) {
+	return calculateElectableItemExpense(input, TH_2026_PARAMETERS.expenses.section40_7.rate, "expense.40_7");
+}
+// src/th/stages/expenses-40-8.ts
+function calculateEntertainerExpense(item) {
+	if (!item) return {
+		requested: 0,
+		allowed: 0,
+		cap: 0,
+		wasClamped: false
+	};
+	const amount = typeof item === "number" ? item : item.amount;
+	if (amount <= 0) return {
+		requested: 0,
+		allowed: 0,
+		cap: 0,
+		wasClamped: false
+	};
+	if (typeof item === "object" && item.expenseElection === "actual") return require_clamp.clampCap(item.actualExpense ?? 0, amount, "expense.40_8.entertainer");
+	const p = TH_2026_PARAMETERS.expenses.section40_8;
+	const tier1 = Math.min(amount, p.entertainerFirstTierThreshold);
+	const tier2 = Math.max(0, amount - p.entertainerFirstTierThreshold);
+	const computed = Math.floor(tier1 * p.entertainerFirstTierRate) + Math.floor(tier2 * p.entertainerSecondTierRate);
+	return require_clamp.clampCap(computed, p.entertainerCeiling, "expense.40_8.entertainer");
+}
+/**
+* Calculates Section 40(8) business, commerce, and entertainer expense deduction.
+*
+* Math: General 60% or actual; entertainer tiered 60%/40% up to 600,000 THB or actual.
+* Units: THB major units.
+*
+* @statute Thailand Royal Decree No. 11 Section 8.
+*/
+function calculateExpenses40_8(input) {
+	if (!input) return {
+		requested: 0,
+		allowed: 0,
+		cap: 0,
+		wasClamped: false
+	};
+	if (typeof input === "number" || "amount" in input) return calculateElectableItemExpense(input, TH_2026_PARAMETERS.expenses.section40_8.generalRate, "expense.40_8.general");
+	const gen = calculateElectableItemExpense(input.general, TH_2026_PARAMETERS.expenses.section40_8.generalRate, "expense.40_8.general");
+	const ent = calculateEntertainerExpense(input.entertainer);
+	const requested = gen.requested + ent.requested;
+	const allowed = gen.allowed + ent.allowed;
+	return {
+		requested,
+		allowed,
+		cap: gen.cap + ent.cap,
+		wasClamped: requested > allowed
+	};
+}
+// src/th/stages/expenses.ts
+/**
+* Aggregates all Section 40(1)–40(8) statutory expense deductions.
+*
+* @statute Thailand Revenue Code Sections 42 bis, 42 ter, 43–46; Royal Decree No. 11.
+*/
+function calculateExpenseDeductions(income = {}, assessable) {
+	const e1_2 = calculateExpenses40_1_2(assessable.section40_1, assessable.section40_2);
+	const e3 = calculateExpenses40_3(income.section40_3, assessable.section40_3);
+	const e4 = calculateExpenses40_4(assessable.section40_4);
+	const e5 = calculateExpenses40_5(income.section40_5);
+	const e6 = calculateExpenses40_6(income.section40_6);
+	const e7 = calculateExpenses40_7(income.section40_7);
+	const e8 = calculateExpenses40_8(income.section40_8);
+	return {
+		section40_1_2: e1_2,
+		section40_3: e3,
+		section40_4: e4,
+		section40_5: e5,
+		section40_6: e6,
+		section40_7: e7,
+		section40_8: e8,
+		total: e1_2.allowed + e3.allowed + e4.allowed + e5.allowed + e6.allowed + e7.allowed + e8.allowed
+	};
+}
+// src/th/stages/minimum-tax.ts
+/**
+* Calculates Section 48(2) Minimum Gross Tax on Section 40(2)–40(8) income.
+*
+* Math: 0.5% of gross Section 40(2)–(8) if gross >= 120,000 THB; payable only if the 0.5% tax exceeds 5,000 THB
+* and exceeds the progressive tax.
+* Units: THB major units.
+*
+* @statute Thailand Revenue Code Section 48(2).
+*/
+function calculateMinimumGrossTax(grossNonEmploymentIncome, progressiveTax) {
+	const p = TH_2026_PARAMETERS.minimumGrossTax;
+	if (grossNonEmploymentIncome < p.incomeThreshold) return {
+		grossEligibleIncome: grossNonEmploymentIncome,
+		rate: p.rate,
+		calculatedTax: 0,
+		threshold: p.taxThreshold,
+		isApplicable: false,
+		wasApplied: false
+	};
+	const currency = TH_2026_PARAMETERS.currency;
+	const minorIncome = require_clamp.toMinorUnits(grossNonEmploymentIncome, currency, "minimumGrossTax");
+	const minorTax = require_clamp.applyPercentage(minorIncome, p.rate);
+	const calculatedTax = require_clamp.fromMinorUnits(minorTax, currency);
+	const isApplicable = calculatedTax > p.taxThreshold;
+	const wasApplied = isApplicable && calculatedTax > progressiveTax;
+	return {
+		grossEligibleIncome: grossNonEmploymentIncome,
+		rate: p.rate,
+		calculatedTax,
+		threshold: p.taxThreshold,
+		isApplicable,
+		wasApplied
+	};
+}
+// src/th/validate.ts
+/**
+* Validates a Thai corporate income tax rate used for the Section 47 bis gross-up.
+*
+* Purpose: Keeps `rate / (1 - rate)` finite before any stage uses the rate.
+* Math: Requires `0 <= rate < 1`.
+* Units: Rate ratio (0.2 = 20%).
+* Throws: TaxValidationError if rate is NaN, non-finite, negative, or at least 1.
+*
+* @param rate Corporate income tax rate ratio.
+* @statute Thailand Revenue Code Section 47 bis.
+*/
+function validateCorpTaxRate(rate) {
+	if (!Number.isFinite(rate) || rate < 0 || rate >= 1) throw new require_clamp.TaxValidationError("income.section40_4.dividends.corpTaxRate", rate, "Corporate tax rate must be finite and satisfy 0 <= rate < 1");
+}
+/**
+* Resolves an optional typed choice (election, payment type, acquisition type) at runtime.
+*
+* Purpose: TypeScript unions are erased at runtime, so untyped callers could otherwise pass an
+* unknown string and silently get the default behaviour.
+* Math: Returns `fallback` when `value` is `undefined`; otherwise requires membership in `choices`.
+* Units: Dimensionless string enum.
+* Throws: TaxValidationError (reported against `field`) if `value` is not one of `choices`.
+*
+* @param value Caller-supplied value, possibly outside the declared union.
+* @param choices Typed const object whose values are the permitted choices.
+* @param fallback Choice used when `value` is `undefined`.
+* @param field Diagnostic field path reported on failure.
+* @statute Jurisdiction-neutral input bound (AGENTS rule 8); no statutory citation.
+*/
+function resolveChoice(value, choices, fallback, field) {
+	if (value === void 0) return fallback;
+	const match = Object.values(choices).find((choice) => choice === value);
+	if (match === void 0) throw new require_clamp.TaxValidationError(field, value, "Value is not a supported choice");
+	return match;
+}
+// src/th/stages/dividend-credit.ts
+/**
+* Calculates the Section 47 bis dividend tax credit for dividends included in regular income.
+*
+* Purpose: Recovers the corporate tax already paid on dividends taxed again in the regular schedule.
+* Math: credit = dividend * corpTaxRate / (1 - corpTaxRate), exact in satang and rounded half-up.
+* The grossed-up amount (dividend + credit) is assessable; the credit offsets tax payable.
+* Units: Inputs and outputs in THB major units; arithmetic in integer satang.
+* Throws: TaxValidationError if dividend is negative/non-finite or the rate is invalid.
+*
+* @param includedDividends Dividends elected `"include"`, in THB.
+* @param corpTaxRate Corporate tax rate in [0, 1); `undefined` means no credit.
+* @statute Thailand Revenue Code Section 47 bis.
+*/
+function calculateDividendTaxCredit(includedDividends, corpTaxRate) {
+	require_clamp.validateMonetaryAmount(includedDividends, "income.section40_4.dividends");
+	if (corpTaxRate === void 0) return {
+		isApplicable: false,
+		dividendAmount: includedDividends,
+		corpTaxRate: 0,
+		credit: 0,
+		grossedUpAmount: includedDividends
+	};
+	validateCorpTaxRate(corpTaxRate);
+	const dividendSatang = toSatang(includedDividends, "income.section40_4.dividends");
+	const creditSatang = require_clamp.applyGrossUp(dividendSatang, corpTaxRate, "income.section40_4.dividends");
+	return {
+		isApplicable: true,
+		dividendAmount: includedDividends,
+		corpTaxRate,
+		credit: fromSatang(creditSatang, "dividendTaxCredit"),
+		grossedUpAmount: fromSatang(dividendSatang + creditSatang, "dividendTaxCredit")
+	};
+}
+// src/th/stages/final-withholding-source.ts
+function electionOf(input, field) {
+	return resolveChoice(typeof input === "object" ? input.election : void 0, ThFinalWithholdingElection, ThFinalWithholdingElection.Include, field);
+}
+/**
+* Resolves one Section 40(4) source: validates its amount and election, withholds if final.
+*
+* Purpose: Applies the per-source final withholding election.
+* Math: tax = amount * rate (satang, half-up) when the election is `"final"`, otherwise 0.
+* Units: Input in THB major units; `satang` and `taxSatang` in integer satang.
+* Throws: TaxValidationError for a negative/non-finite amount or an unknown election value.
+*
+* @param input Bare amount, source object, or undefined.
+* @param field Diagnostic path of the amount.
+* @param electionField Diagnostic path of the election.
+* @param rate Final withholding rate (ratio).
+* @statute Thailand Revenue Code Sections 40(4), 50(2)(g), 57 ter.
+*/
+function resolveSource(input, field, electionField, rate) {
+	const amount = extractElectableAmount(input, field);
+	const election = electionOf(input, electionField);
+	const satang = toSatang(amount, field);
+	const taxSatang = election === ThFinalWithholdingElection.Final ? require_clamp.applyPercentage(satang, rate) : 0;
+	return {
+		breakdown: {
+			election,
+			amount,
+			rate,
+			tax: fromSatang(taxSatang)
+		},
+		satang,
+		taxSatang
+	};
+}
+// src/th/stages/final-withholding.ts
+function toStructuredInput(input) {
+	return typeof input === "number" ? { amount: input } : input ?? {};
+}
+function sumSatang(sources, seed = 0) {
+	return sources.reduce((sum, source) => sum + source.satang, seed);
+}
+/**
+* Splits Section 40(4) income into regular-bracket income and final-withheld income.
+*
+* Purpose: Applies each source's election so only included income reaches the regular schedule.
+* Math: For each source elected `"final"`, tax = amount * rate (satang, half-up) and the income is
+* excluded from regular brackets. `"include"` (default) adds the income to Section 40(4)
+* assessable income at a 0% expense rate.
+* Units: Inputs and outputs in THB major units; arithmetic in integer satang.
+* Throws: TaxValidationError for negative/non-finite amounts or an invalid `corpTaxRate`.
+*
+* @param input Bare amount, structured sources, or undefined.
+* @statute Thailand Revenue Code Sections 40(4), 50(2)(g), 56, 57 ter.
+*/
+function resolveSection40_4(input) {
+	const section = toStructuredInput(input);
+	const rates = TH_2026_PARAMETERS.finalWithholding;
+	const base = extractElectableAmount(section.amount, "income.section40_4");
+	const interest = resolveSource(section.interest, "income.section40_4.interest", "income.section40_4.interest.election", rates.interestRate);
+	const dividends = resolveSource(section.dividends, "income.section40_4.dividends", "income.section40_4.dividends.election", rates.dividendRate);
+	const digital = resolveSource(section.digitalAssets, "income.section40_4.digitalAssets", "income.section40_4.digitalAssets.election", rates.digitalAssetRate);
+	const corpTaxRate = typeof section.dividends === "object" ? section.dividends.corpTaxRate : void 0;
+	if (corpTaxRate !== void 0) validateCorpTaxRate(corpTaxRate);
+	const sources = [
+		interest,
+		dividends,
+		digital
+	];
+	const isFinal = (source) => source.breakdown.election === ThFinalWithholdingElection.Final;
+	const finalSources = sources.filter(isFinal);
+	const includedSatang = sumSatang(sources.filter((source) => !isFinal(source)), toSatang(base, "income.section40_4"));
+	const isDividendIncluded = !isFinal(dividends);
+	return {
+		includedAmount: fromSatang(includedSatang),
+		includedDividends: isDividendIncluded ? dividends.breakdown.amount : 0,
+		corpTaxRate: isDividendIncluded ? corpTaxRate : void 0,
+		finalWithholding: {
+			interest: interest.breakdown,
+			dividends: dividends.breakdown,
+			digitalAssets: digital.breakdown,
+			totalAmount: fromSatang(sumSatang(finalSources)),
+			totalTax: fromSatang(finalSources.reduce((sum, source) => sum + source.taxSatang, 0))
+		}
+	};
+}
+// src/th/stages/real-estate-expense.ts
+/**
+* Caps the holding period used by Section 48(4) at the statutory maximum.
+*
+* Purpose: More than 10 years of holding counts as 10 years.
+* Math: min(requestedYears, `realEstate.maxHoldingYears`).
+* Units: Dimensionless year count (callers round part-years up).
+* Throws: Never; `requestedYears` is validated by the caller.
+*
+* @param requestedYears Validated positive safe integer holding period.
+* @statute Thailand Revenue Code Section 48(4); Ministerial Regulation No. 126.
+*/
+function effectiveHoldingYears(requestedYears) {
+	return Math.min(requestedYears, TH_2026_PARAMETERS.realEstate.maxHoldingYears);
+}
+/**
+* Selects the Section 48(4) expense rate for the acquisition type.
+*
+* Purpose: Inherited or gifted property takes a flat rate; commercial or other property takes the
+* holding-year table. The two are never combined.
+* Math: Flat `inheritanceExpenseRate`, or the last `expenseTable` row with `minYears <= years`.
+* Units: Rate ratio; `years` is the effective (capped) holding period.
+* Throws: Never; the acquisition type is validated by the caller.
+*
+* @param acquisitionType Validated acquisition type.
+* @param years Effective holding years.
+* @statute Thailand Revenue Code Section 48(4); Ministerial Regulation No. 126.
+*/
+function resolveRealEstateExpense(acquisitionType, years) {
+	const rules = TH_2026_PARAMETERS.realEstate;
+	if (acquisitionType === ThRealEstateAcquisitionType.InheritanceOrGift) return {
+		basis: ThRealEstateExpenseBasis.FlatInheritance,
+		rate: rules.inheritanceExpenseRate
+	};
+	const rate = rules.expenseTable.reduce((acc, row) => years >= row.minYears ? row.rate : acc, 0);
+	return {
+		basis: ThRealEstateExpenseBasis.HoldingPeriodTable,
+		rate
+	};
+}
+// src/th/stages/real-estate.ts
+const EMPTY_BREAKDOWN = {
+	grossTransferValue: 0,
+	acquisitionType: ThRealEstateAcquisitionType.Commercial,
+	expenseBasis: ThRealEstateExpenseBasis.HoldingPeriodTable,
+	requestedHoldingYears: 0,
+	effectiveHoldingYears: 0,
+	expenseRate: 0,
+	expense: 0,
+	netGain: 0,
+	annualGain: 0,
+	brackets: evaluateThBrackets(0, 0).brackets,
+	annualTax: 0,
+	taxBeforeCap: 0,
+	taxCap: 0,
+	wasClamped: false,
+	tax: 0
+};
+/**
+* Scales every finite annualised-schedule bracket bound by the holding period.
+*
+* Math: `years * tax(net / years)` equals the tax on `net` against bounds multiplied by `years`
+* (each slice `rate * clip(net/years - lo, 0, width) * years = rate * clip(net - lo*years, 0, width*years)`),
+* so the annualisation needs no intermediate rounding.
+* Units: THB major units; scaling performed in integer satang.
+* Throws: TaxValidationError if a scaled bound exceeds the safe integer range (unreachable
+* for the capped holding period).
+*/
+function scaleBracketsByYears(years) {
+	return TH_2026_PARAMETERS.realEstate.brackets.map((bracket) => {
+		if (bracket.upTo === null) return bracket;
+		return {
+			upTo: fromSatang(require_clamp.multiplySafeInteger(toSatang(bracket.upTo), years, "realEstateTransfer.holdingYears")),
+			rate: bracket.rate
+		};
+	});
+}
+/**
+* Clamps real estate tax at the statutory share of the gross transfer value.
+*
+* Purpose: Applies the Section 48(4) ceiling on the separately computed tax.
+* Math: taxCap = grossMinor * `realEstate.taxCapRate` (20%, half-up); tax = min(taxBeforeCap, taxCap).
+* Units: Integer minor units (satang) in and out.
+* Throws: TaxValidationError if `grossMinor` is not a non-negative safe integer.
+* Note: Unreachable end to end (top rate 35% of at most 50% net is 17.5% < 20%); kept as the
+* statutory guard.
+*
+* @param taxBeforeCap Uncapped tax in satang.
+* @param grossMinor Gross transfer value in satang.
+* @statute Thailand Revenue Code Section 48(4).
+*/
+function applyRealEstateCap(taxBeforeCap, grossMinor) {
+	const taxCap = require_clamp.applyPercentage(grossMinor, TH_2026_PARAMETERS.realEstate.taxCapRate);
+	return {
+		taxCap,
+		tax: Math.min(taxBeforeCap, taxCap),
+		wasClamped: taxBeforeCap > taxCap
+	};
+}
+/**
+* Calculates Section 48(4) tax on an inherited, gifted, or sold real estate transfer.
+*
+* Purpose: Taxes the gain as if earned evenly over the holding period, then scales back up.
+* `grossTransferValue` must be the official appraised value (ราคาประเมินทุนทรัพย์, Section 49 bis),
+* not the actual sale price. `holdingYears` is a positive safe integer; callers round part-years
+* up, and more than 10 years counts as 10.
+* Math: years = min(holdingYears, 10); expense = gross * 50% for inheritance/gift, otherwise
+* gross * table(years) (never combined); net = gross - expense; tax = years * bracketTax(net / years)
+* on the schedule without a 0% tier (5% from the first baht), evaluated exactly as bracketTax of
+* `net` against bounds multiplied by `years` (no per-year rounding); tax is clamped at 20% of gross
+* (which the 35% top rate on at most 50% net can never reach). `annualGain` and `annualTax` are
+* rounded for display.
+* Units: Inputs and outputs in THB major units; arithmetic in integer satang.
+* Throws: TaxValidationError for a negative/non-finite value, a non-positive/non-safe-integer
+* holding period, or an unknown `acquisitionType`.
+*
+* @statute Thailand Revenue Code Section 48(4), Section 42(5), Section 49 bis.
+*/
+function calculateRealEstateTransfer(input) {
+	if (input === void 0) return EMPTY_BREAKDOWN;
+	require_clamp.validateMonetaryAmount(input.grossTransferValue, "realEstateTransfer.grossTransferValue");
+	require_clamp.validateSafeIntegerCount(input.holdingYears, "realEstateTransfer.holdingYears", 1);
+	const acquisitionType = resolveChoice(input.acquisitionType, ThRealEstateAcquisitionType, ThRealEstateAcquisitionType.Commercial, "realEstateTransfer.acquisitionType");
+	const years = effectiveHoldingYears(input.holdingYears);
+	const { basis, rate: expenseRate } = resolveRealEstateExpense(acquisitionType, years);
+	const gross = toSatang(input.grossTransferValue, "realEstateTransfer.grossTransferValue");
+	const expense = require_clamp.applyPercentage(gross, expenseRate);
+	const netGain = gross - expense;
+	const evaluated = evaluateThBracketSet(fromSatang(netGain), fromSatang(netGain), scaleBracketsByYears(years));
+	const taxBeforeCap = toSatang(evaluated.totalTax);
+	const capped = applyRealEstateCap(taxBeforeCap, gross);
+	return {
+		grossTransferValue: input.grossTransferValue,
+		acquisitionType,
+		expenseBasis: basis,
+		requestedHoldingYears: input.holdingYears,
+		effectiveHoldingYears: years,
+		expenseRate,
+		expense: fromSatang(expense),
+		netGain: fromSatang(netGain),
+		annualGain: fromSatang(require_clamp.roundHalfUp(netGain / years)),
+		brackets: evaluated.brackets,
+		annualTax: fromSatang(require_clamp.roundHalfUp(taxBeforeCap / years)),
+		taxBeforeCap: fromSatang(taxBeforeCap),
+		taxCap: fromSatang(capped.taxCap),
+		wasClamped: capped.wasClamped,
+		tax: fromSatang(capped.tax)
+	};
+}
+// src/th/stages/regular-income.ts
+/**
+* Assembles the income that flows through the regular progressive schedule.
+*
+* Math: Section 40(1) = declared Section 40(1) + ineligible Section 48(5) lump sum;
+* Section 40(4) = included Section 40(4) income (final-withheld sources excluded)
+* + Section 47 bis gross-up. Other categories pass through untouched.
+* Units: THB major units; the Section 40(1) sum is performed in integer satang.
+* Throws: TaxValidationError if the declared Section 40(1) is negative or non-finite.
+*
+* @param income Declared Section 40 income.
+* @param special Lump sum, included Section 40(4) income, and dividend gross-up.
+* @statute Thailand Revenue Code Sections 40(1), 40(4), 47 bis, 48(5).
+*/
+function buildRegularIncome(income, special) {
+	const declared = income?.section40_1 ?? 0;
+	require_clamp.validateMonetaryAmount(declared, "income.section40_1");
+	const section40_1 = toSatang(declared, "income.section40_1") + toSatang(special.lumpSum, "income.section40_1");
+	const section40_4 = toSatang(special.section40_4, "income.section40_4") + toSatang(special.dividendCredit, "income.section40_4");
+	return {
+		...income,
+		section40_1: fromSatang(section40_1),
+		section40_4: fromSatang(section40_4)
+	};
+}
+// src/th/stages/separate-sheet.ts
+const EMPTY_INPUT = {
+	amount: 0,
+	yearsOfService: 0,
+	lastDailyWage: 0
+};
+/**
+* Calculates the Section 48(5) separate sheet for one-time severance/retirement lump sums.
+*
+* Purpose: Applies the severance exemption, then taxes an eligible remainder on its own schedule
+* or returns the ineligible remainder for regular treatment.
+* Math: For `paymentType` severance (the default) at ANY length of service:
+* exemption = min(amount, 400 * lastDailyWage, 600,000); `"retirement"` payments get none.
+* remainder = amount - exemption. With yearsOfService >= 5: fixed = min(7,000 * years, remainder);
+* percentage expense = 50% of (remainder - fixed), half-up; net = remainder - fixed - percentage,
+* taxed on the separate schedule (5%..35%, no 0% tier). With fewer than 5 years only the remainder
+* is returned in `addedToSection40_1` for the regular computation.
+* Units: Inputs and outputs in THB major units; arithmetic in integer satang.
+* Throws: TaxValidationError for negative/non-finite money, a non-safe-integer/negative `yearsOfService`,
+* an unknown `paymentType`, or a wage/years value whose scaled satang amount exceeds safe integers.
+*
+* @statute Thailand Revenue Code Section 48(5); Section 42(1) (severance exemption).
+*/
+function calculateSeparateSheet(input = EMPTY_INPUT) {
+	const rules = TH_2026_PARAMETERS.separateSheet;
+	require_clamp.validateMonetaryAmount(input.amount, "separateSheet.amount");
+	require_clamp.validateMonetaryAmount(input.lastDailyWage, "separateSheet.lastDailyWage");
+	require_clamp.validateSafeIntegerCount(input.yearsOfService, "separateSheet.yearsOfService");
+	const paymentType = resolveChoice(input.paymentType, ThSeparateSheetPaymentType, ThSeparateSheetPaymentType.Severance, "separateSheet.paymentType");
+	const years = input.yearsOfService;
+	const isEligible = years >= rules.minYearsOfService;
+	const amountSatang = toSatang(input.amount, "separateSheet.amount");
+	const wageSatang = toSatang(input.lastDailyWage, "separateSheet.lastDailyWage");
+	const isSeverance = paymentType === ThSeparateSheetPaymentType.Severance;
+	const wageCap = isSeverance ? require_clamp.multiplySafeInteger(wageSatang, rules.exemptionWageDays, "separateSheet.lastDailyWage") : 0;
+	const exemption = isSeverance ? Math.min(amountSatang, wageCap, toSatang(rules.exemptionCeiling)) : 0;
+	const remainder = amountSatang - exemption;
+	const fixedCap = require_clamp.multiplySafeInteger(toSatang(rules.expensePerYearOfService), years, "separateSheet.yearsOfService");
+	const fixed = isEligible ? Math.min(remainder, fixedCap) : 0;
+	const percentage = isEligible ? require_clamp.applyPercentage(remainder - fixed, rules.remainderExpenseRate) : 0;
+	const net = fromSatang(isEligible ? remainder - fixed - percentage : 0);
+	const evaluated = evaluateThBracketSet(net, net, rules.brackets);
+	return {
+		amount: input.amount,
+		yearsOfService: years,
+		lastDailyWage: input.lastDailyWage,
+		isEligible,
+		addedToSection40_1: isEligible ? 0 : fromSatang(remainder),
+		wageBasedCap: fromSatang(wageCap),
+		exemptionCeiling: rules.exemptionCeiling,
+		paymentType,
+		exemption: fromSatang(exemption),
+		remainder: fromSatang(remainder),
+		fixedExpense: fromSatang(fixed),
+		percentageExpense: fromSatang(percentage),
+		netTaxable: net,
+		brackets: evaluated.brackets,
+		tax: evaluated.totalTax
+	};
+}
+// src/th/stages/special-regimes.ts
+/**
+* Resolves Section 40(4) elections, the Section 47 bis credit, the Section 48(5) separate sheet,
+* and the Section 48(4) real estate transfer, then assembles the remaining regular income.
+*
+* Math: Regular Section 40(4) = included sources + dividend gross-up; ineligible lump sum joins
+* Section 40(1). Gross outside the regular schedule = final-elected 40(4) + eligible lump sum (or, if
+* ineligible, its severance exemption) + real estate gross transfer value.
+* Units: THB major units; sums performed in integer satang.
+* Throws: TaxValidationError for any invalid special-regime input.
+*
+* @statute Thailand Revenue Code Sections 40(4), 47 bis, 48(4), 48(5).
+*/
+function resolveSpecialRegimes(input) {
+	const section40_4 = resolveSection40_4(input.income?.section40_4);
+	const dividendTaxCredit = calculateDividendTaxCredit(section40_4.includedDividends, section40_4.corpTaxRate);
+	const separateSheet = calculateSeparateSheet(input.separateSheet);
+	const realEstate = calculateRealEstateTransfer(input.realEstateTransfer);
+	return {
+		regularIncome: buildRegularIncome(input.income, {
+			lumpSum: separateSheet.addedToSection40_1,
+			section40_4: section40_4.includedAmount,
+			dividendCredit: dividendTaxCredit.credit
+		}),
+		grossOutsideRegular: sumThAmounts([
+			section40_4.finalWithholding.totalAmount,
+			separateSheet.isEligible ? separateSheet.amount : separateSheet.exemption,
+			realEstate.grossTransferValue
+		], "grossIncome"),
+		finalWithholding: section40_4.finalWithholding,
+		dividendTaxCredit,
+		separateSheet,
+		realEstate
+	};
+}
+// src/th/stages/pipeline.ts
+function validateYear(year) {
+	if (year !== void 0 && year !== TH_2026_PARAMETERS.taxYear) throw new require_clamp.TaxValidationError("taxYear", year, "Unsupported tax year; only 2026 is currently supported");
+}
+/**
+* Executes full Thailand PIT calculation pipeline for ภ.ง.ด.90/91.
+*
+* @statute Thailand Revenue Code Sections 40, 42 bis, 47, 47 bis, 48(1)–(5).
+*/
+function runThTaxPipeline(input = {}) {
+	validateYear(input.taxYear);
+	const filingStatus = input.filingStatus ?? "single";
+	const withholding = input.withholdingTax ?? 0;
+	require_clamp.validateMonetaryAmount(withholding, "withholdingTax");
+	const special = resolveSpecialRegimes(input);
+	const income = special.regularIncome;
+	const assessable = calculateAssessableIncome(income);
+	const expenses = calculateExpenseDeductions(income, assessable);
+	const netIncomeAfterExpenses = Math.max(0, assessable.total - expenses.total);
+	const allowancesRes = calculateAllowances(input.allowances, filingStatus, assessable.total, expenses.total, assessable.section40_1);
+	const evalBrackets = evaluateThBrackets(allowancesRes.netTaxableIncome, assessable.total);
+	const progressiveTax = evalBrackets.totalTax;
+	const minimumGrossTax = calculateMinimumGrossTax(assessable.grossNonEmploymentIncome, progressiveTax);
+	const regularTax = minimumGrossTax.wasApplied ? minimumGrossTax.calculatedTax : progressiveTax;
+	const combined = combineThLiability({
+		regularTax,
+		separateSheetTax: special.separateSheet.tax,
+		realEstateTax: special.realEstate.tax,
+		finalWithholdingTax: special.finalWithholding.totalTax,
+		dividendTaxCredit: special.dividendTaxCredit.credit,
+		withholdingTax: withholding
+	});
+	const grossIncome = sumThAmounts([assessable.total, special.grossOutsideRegular], "grossIncome");
+	const effectiveRate = grossIncome > 0 ? combined.totalCombinedTax / grossIncome : 0;
+	const breakdown = {
+		assessableIncome: assessable,
+		expenseDeductions: expenses,
+		netIncomeAfterExpenses,
+		allowances: allowancesRes.breakdown,
+		netTaxableIncome: allowancesRes.netTaxableIncome,
+		progressiveTax,
+		progressiveBrackets: evalBrackets.brackets,
+		minimumGrossTax,
+		withholdingTax: withholding,
+		netTaxPayable: combined.netTaxPayable,
+		regularTax,
+		separateSheet: special.separateSheet,
+		realEstate: special.realEstate,
+		finalWithholding: special.finalWithholding,
+		dividendTaxCredit: special.dividendTaxCredit,
+		totalCombinedTax: combined.totalCombinedTax
+	};
+	return {
+		jurisdiction: "TH",
+		taxYear: TH_2026_PARAMETERS.taxYear,
+		currency: TH_2026_PARAMETERS.currency,
+		grossIncome: require_clamp.thb(grossIncome, "grossIncome"),
+		taxableIncome: require_clamp.thb(allowancesRes.netTaxableIncome, "taxableIncome"),
+		totalTax: require_clamp.thb(combined.totalCombinedTax, "totalTax"),
+		effectiveRate,
+		marginalRate: evalBrackets.brackets.marginalRate,
+		netTaxPayable: require_clamp.thb(combined.netTaxPayable, "netTaxPayable", { allowNegative: true }),
+		breakdown
+	};
+}
+// src/th/calculate.ts
+/**
+* Calculates Thailand Personal Income Tax (ภ.ง.ด.90/91) under Revenue Code.
+*
+* Defaults to tax year 2026 and single filing status.
+*
+* @param input Taxpayer assessable income, allowances, filing status, and withholding.
+* @returns Fully typed, immutable TaxResult with statutory breakdown.
+*
+* @statute Thailand Revenue Code Sections 40, 42 bis, 47, 48(1)–(2).
+*/
+function calculateThTax(input = {}) {
+	return runThTaxPipeline(input);
+}
+// src/th/system.ts
+/**
+* Thailand Tax System implementation for 2026.
+*
+* Implements TaxSystem contract for `@trajectonomics/tax/th`.
+*/
+const th = {
+	jurisdiction: "TH",
+	taxYear: 2026,
+	currency: "THB",
+	calculate(input = {}) {
+		return calculateThTax(input);
+	}
+};
+exports.TH_2026_PARAMETERS = TH_2026_PARAMETERS;
+exports.ThFinalWithholdingElection = ThFinalWithholdingElection;
+exports.ThRealEstateAcquisitionType = ThRealEstateAcquisitionType;
+exports.ThRealEstateExpenseBasis = ThRealEstateExpenseBasis;
+exports.ThSeparateSheetPaymentType = ThSeparateSheetPaymentType;
+exports.calculateThTax = calculateThTax;
+exports.th = th;
+
+//# sourceMappingURL=index.cjs.map