@trajectonomics/tax 0.1.1-alpha.0 → 0.2.0-alpha.1

package/dist/th/index.mjs

@@ -1,4 +1,4 @@
-import { c as roundHalfUp, d as multiplySafeInteger, f as validateMonetaryAmount, i as thb, l as fromMinorUnits, m as TaxValidationError, n as evaluateBrackets, o as applyGrossUp, p as validateSafeIntegerCount, s as applyPercentage, t as clampCap, u as toMinorUnits } from "../clamp-Bse4u0H-.mjs";
+import { c as roundHalfUp, d as toMinorUnits, f as multiplySafeInteger, h as TaxValidationError, i as thb, l as rateFraction, m as validateSafeIntegerCount, n as evaluateBrackets, o as applyGrossUp, p as validateMonetaryAmount, s as applyPercentage, t as clampCap, u as fromMinorUnits } from "../clamp-CdcDymBJ.mjs";
 // src/th/parameters-brackets.ts
 /**
 * Section 48(1) progressive net-income brackets for Tax Year 2026 (THB major units, rates as ratios).
@@ -1454,6 +1454,1066 @@ function runThTaxPipeline(input = {}) {
 function calculateThTax(input = {}) {
 	return runThTaxPipeline(input);
 }
+// src/th/levy/graph-types.ts
+/**
+* Tally bases sim-core's `tally` Measure reads.
+*
+* Purpose: Distinguishes income Flows from contribution Flows at the tally.
+* Math: No arithmetic; a discriminator only.
+* Units: Dimensionless.
+* Throws: Nothing.
+* @statute Thailand Revenue Code Sections 40(1)–(8) (gross) and 47 (funded).
+*/
+const ThLevyTallyBasis = {
+	/** Sums income Flows. */
+	Gross: "gross",
+	/** Sums contribution Flows. */
+	Funded: "funded"
+};
+/**
+* Rounding modes sim-core's `scale` Measure accepts.
+*
+* Purpose: Names the three rounding policies embedded in emitted Measures.
+* Math: `Floor` rounds down, `Ceil` up, and `HalfUp` sends ties away from zero.
+* Units: Dimensionless.
+* Throws: Nothing.
+* @statute Thailand Revenue Code Sections 47 bis, 48(1), 48(2).
+*/
+const ThLevyRounding = {
+	Floor: "floor",
+	HalfUp: "halfUp",
+	Ceil: "ceil"
+};
+// src/th/levy/graph-rates.ts
+/**
+* Emits a satang sum of Measure ids; an empty list becomes a zero const.
+*
+* Purpose: Keeps statutory totals readable without a fold at every call site.
+* Math: Left-associative `add`; empty input yields `const 0`. When `name` is given, a final
+* zero addition exposes the running total under an audited id (sim-core has no rename op).
+* Units: Integer satang in and out.
+* Throws: TaxValidationError if the graph rejects an id or constant.
+* @statute Jurisdiction-neutral graph helper; no statutory citation.
+*/
+function sumMeasures(graph, ids, name) {
+	const [first, ...rest] = ids;
+	let total = first ?? graph.constant(0);
+	for (const id of rest) total = graph.add(total, id);
+	return name === void 0 ? total : graph.add(total, graph.constant(0), name);
+}
+/**
+* Emits `of` rounded down to a whole baht while keeping satang units.
+*
+* Purpose: Reproduces the calculator's whole-baht `Math.floor` steps exactly.
+* Math: `100 * floor(x / 100)` via two integer scales.
+* Units: Integer satang in and out.
+* Throws: Nothing; `of` must name an emitted Measure.
+* @statute Thailand Revenue Code Section 42 bis (whole-baht expense rounding).
+*/
+function flooredToBaht(graph, of) {
+	return graph.scale(graph.scale(of, 1, 100, ThLevyRounding.Floor), 100, 1, ThLevyRounding.Floor);
+}
+/**
+* Emits `floor(income * rate)`, rounded down to a whole baht.
+*
+* Purpose: Mirrors the calculator's `Math.floor(major * rate)` expense deduction.
+* Math: `100 * floor(x * num / (den * 100))`.
+* Units: Integer satang in and out; `rate` is dimensionless.
+* Throws: TaxValidationError if `rate` is outside [0, 1].
+* @statute Thailand Revenue Code Sections 42 bis, 42 ter, 43–46.
+*/
+function rateFlooredToBaht(graph, of, rate) {
+	const { num, den } = rateFraction(rate);
+	return flooredToBaht(graph, graph.scale(of, num, den, ThLevyRounding.Floor));
+}
+/**
+* Emits `min(of, ceiling)`, the shape `clampCap` uses for an absolute statutory ceiling.
+*
+* Purpose: Reproduces the absolute-ceiling branch of `clampCap`.
+* Math: `min(x, ceiling)`.
+* Units: Integer satang in and out.
+* Throws: TaxValidationError if the ceiling is not safe integer satang.
+* @statute Thailand Revenue Code Section 47 (allowance ceilings).
+*/
+function capAt(graph, of, ceilingSatang) {
+	return graph.min(of, graph.constant(ceilingSatang));
+}
+/**
+* Emits `min(of * rate, ceiling)` with half-up satang rounding, the shape `resolveCap` computes.
+*
+* Purpose: Percentage-of-income retirement caps round to the nearest satang, not to a baht.
+* Math: `min(round_half_up(x * num / den), ceiling)`.
+* Units: Integer satang in and out; `rate` is dimensionless.
+* Throws: TaxValidationError if `rate` is outside [0, 1] or the ceiling is invalid.
+* @statute Thailand Revenue Code Section 47; Ministerial Regulations No. 126, 390.
+*/
+function rateCapAt(graph, of, rate, ceilingSatang) {
+	const { num, den } = rateFraction(rate);
+	return capAt(graph, graph.scale(of, num, den, ThLevyRounding.HalfUp), ceilingSatang);
+}
+// src/th/levy/measure-ids.ts
+/**
+* Audited Measure ids a TH 2026 Levy exposes by name.
+*
+* Purpose: Lets callers and tests compare each intermediate statutory figure without knowing
+* the emit order.
+* Math: No arithmetic; Measure ids only.
+* Units: The referenced Measures are integer satang.
+* Throws: Nothing.
+* @statute Thailand Revenue Code Sections 40, 42 bis, 47, 47 bis, 48(1)–(2).
+*/
+let ThLevyMeasureId = /* @__PURE__ */ function(ThLevyMeasureId) {
+	ThLevyMeasureId["AssessableTotal"] = "assessable.total";
+	ThLevyMeasureId["GrossNonEmployment"] = "assessable.non_employment";
+	ThLevyMeasureId["ExpensesTotal"] = "expenses.total";
+	ThLevyMeasureId["AllowancesFixed"] = "allowances.fixed";
+	ThLevyMeasureId["RetirementCluster"] = "allowances.retirement_cluster";
+	ThLevyMeasureId["ThaiEsg"] = "allowances.thai_esg";
+	ThLevyMeasureId["Donations"] = "allowances.donations";
+	ThLevyMeasureId["AllowancesTotal"] = "allowances.total";
+	ThLevyMeasureId["NetTaxableIncome"] = "taxable.income";
+	ThLevyMeasureId["ProgressiveTax"] = "tax.progressive";
+	ThLevyMeasureId["MinimumGrossTax"] = "tax.minimum";
+	ThLevyMeasureId["RegularTax"] = "tax.regular";
+	ThLevyMeasureId["FinalWithholdingTax"] = "tax.final_withholding";
+	ThLevyMeasureId["DividendCredit"] = "credit.dividend";
+	ThLevyMeasureId["TotalTax"] = "tax.total";
+	ThLevyMeasureId["NetTaxPayable"] = "tax.net_payable";
+	return ThLevyMeasureId;
+}({});
+// src/th/levy/allowances-donations.ts
+/**
+* Emits the Section 47(7) donation allowances against the net income before donations.
+*
+* Purpose: Reproduces the 2x-then-1x donation caps as Measures.
+* Math: 2x donations are doubled, then `min(doubled, floor(net * 10%))`; 1x donations are
+* `min(amount, floor(remaining net * 10%))`. Taxable income is `max(0, remaining - 1x allowed)`.
+* Units: Profile amounts are THB major units; Measures are integer satang.
+* Throws: TaxValidationError if a donation amount is invalid or the doubled amount overflows.
+*
+* @param graph Measure graph being built.
+* @param netBefore `max(0, assessable - expenses - non-donation allowances)` Measure.
+* @param requested2x Requested 2x-qualified donation in THB.
+* @param requested1x Requested general donation in THB.
+* @statute Thailand Revenue Code Section 47(7); Royal Decrees No. 428, 558.
+*/
+function addDonationAllowances(graph, netBefore, requested2x, requested1x) {
+	const p = TH_2026_PARAMETERS.allowances.donations;
+	const raw2x = requested2x ?? 0;
+	const raw1x = requested1x ?? 0;
+	validateMonetaryAmount(raw2x, "allowance.donation_2x");
+	validateMonetaryAmount(raw1x, "allowance.donation_1x");
+	const doubled = multiplySafeInteger(toSatang(raw2x, "allowance.donation_2x"), p.donation2xMultiplier, "allowance.donation_2x");
+	const net = graph.max(netBefore, graph.constant(0));
+	const cap2x = rateFlooredToBaht(graph, net, p.donation2xMaxRate);
+	const allowed2x = graph.min(graph.constant(doubled), cap2x);
+	const remaining = graph.max(graph.sub(net, allowed2x), graph.constant(0));
+	const cap1x = rateFlooredToBaht(graph, remaining, p.donation1xMaxRate);
+	const allowed1x = graph.min(graph.constant(toSatang(raw1x, "allowance.donation_1x")), cap1x);
+	return {
+		total: graph.add(allowed2x, allowed1x, "allowances.donations"),
+		netTaxable: graph.max(graph.sub(remaining, allowed1x), graph.constant(0), "taxable.income")
+	};
+}
+// src/th/levy/allowances-fixed.ts
+/**
+* Computes the fixed allowance total frozen into the Levy.
+*
+* Purpose: Reuses the calculator's own family and insurance stages, so the const Measure cannot
+* drift from the rules it mirrors.
+* Math: Sum of the allowed personal, spouse, children, parents, disabled, social security,
+* life/health insurance, parent health, spouse life, and mortgage interest amounts.
+* Units: THB major units in, integer satang out.
+* Throws: TaxValidationError if any profile allowance amount is invalid.
+*
+* @param allowances Fixed profile allowances.
+* @param status Filing status governing spouse and parent eligibility.
+* @statute Thailand Revenue Code Section 47(1)(a)–(j).
+*/
+function fixedAllowanceSatang(allowances, status) {
+	const family = calculateFamilyAllowances(allowances, status);
+	const insurance = calculateInsuranceAllowances(allowances, status);
+	return [
+		family.personal.allowed,
+		family.spouse.allowed,
+		family.children.allowed,
+		family.parents.allowed,
+		family.disabled.allowed,
+		insurance.socialSecurity.allowed,
+		insurance.lifeInsurance.allowed,
+		insurance.parentHealthInsurance.allowed,
+		insurance.spouseLifeInsurance.allowed,
+		insurance.mortgageInterest.allowed
+	].reduce((sum, value) => sum + toSatang(value), 0);
+}
+/**
+* Emits the Section 47 fixed allowance total as one const Measure.
+*
+* Purpose: Freezes the profile-only allowances into a single named Measure.
+* Math: `const(fixedAllowanceSatang(...))`.
+* Units: Integer satang.
+* Throws: TaxValidationError if a profile allowance amount is invalid.
+*
+* @param graph Measure graph being built.
+* @param allowances Fixed profile allowances.
+* @param status Filing status governing eligibility.
+* @statute Thailand Revenue Code Section 47(1)(a)–(j).
+*/
+function addFixedAllowances(graph, allowances, status) {
+	return graph.constant(fixedAllowanceSatang(allowances, status), "allowances.fixed");
+}
+// src/th/levy/labels.ts
+/**
+* Tally labels a TH 2026 Levy reads from income Flows (`gross` basis).
+*
+* Purpose: One label per assessable income class under Section 40(1)–(8), with Section 40(4)
+* split per source because each source carries its own final-withholding election at emit time.
+* Math: No arithmetic; the label selects which tally a Measure reads.
+* Units: Dimensionless label string; the tallied amount is integer satang.
+* Throws: Nothing.
+* @statute Thailand Revenue Code Sections 40(1)–(8), 40(4), 50(2)(g).
+*/
+const ThLevyIncomeLabel = {
+	/** Section 40(1) employment income. */
+	Section40_1: "income.section40_1",
+	/** Section 40(2) service and hire-of-work income. */
+	Section40_2: "income.section40_2",
+	/** Section 40(3) royalties, goodwill, and copyright income. */
+	Section40_3: "income.section40_3",
+	/** Section 40(4) income with no source-specific election. */
+	Section40_4Other: "income.section40_4",
+	/** Section 40(4) interest, elected final or included at emit time. */
+	Section40_4Interest: "income.section40_4.interest",
+	/** Section 40(4) dividends, elected final or included at emit time. */
+	Section40_4Dividends: "income.section40_4.dividends",
+	/** Section 40(4) digital asset income, elected final or included at emit time. */
+	Section40_4DigitalAssets: "income.section40_4.digitalAssets",
+	/** Section 40(5) building rental income. */
+	Section40_5Building: "income.section40_5.building",
+	/** Section 40(5) agricultural land rental income. */
+	Section40_5AgriculturalLand: "income.section40_5.agriculturalLand",
+	/** Section 40(5) non-agricultural land rental income. */
+	Section40_5NonAgriculturalLand: "income.section40_5.nonAgriculturalLand",
+	/** Section 40(5) vehicle rental income. */
+	Section40_5Vehicles: "income.section40_5.vehicles",
+	/** Section 40(5) other rental income. */
+	Section40_5Other: "income.section40_5.other",
+	/** Section 40(6) medical profession income. */
+	Section40_6Medical: "income.section40_6.medical",
+	/** Section 40(6) law profession income. */
+	Section40_6Law: "income.section40_6.law",
+	/** Section 40(6) engineering profession income. */
+	Section40_6Engineering: "income.section40_6.engineering",
+	/** Section 40(6) architecture profession income. */
+	Section40_6Architecture: "income.section40_6.architecture",
+	/** Section 40(6) accounting profession income. */
+	Section40_6Accounting: "income.section40_6.accounting",
+	/** Section 40(6) fine arts profession income. */
+	Section40_6FineArts: "income.section40_6.fineArts",
+	/** Section 40(6) other liberal profession income. */
+	Section40_6Other: "income.section40_6.other",
+	/** Section 40(7) contracting income. */
+	Section40_7: "income.section40_7",
+	/** Section 40(8) general business and commerce income. */
+	Section40_8General: "income.section40_8.general",
+	/** Section 40(8) entertainer income (tiered expense rate). */
+	Section40_8Entertainer: "income.section40_8.entertainer"
+};
+/**
+* Tally labels a TH 2026 Levy reads from contribution Flows (`funded` basis).
+*
+* Purpose: One label per contribution-driven retirement allowance.
+* Math: No arithmetic; the label selects which tally a Measure reads.
+* Units: Dimensionless label string; the tallied amount is integer satang.
+* Throws: Nothing.
+* @statute Thailand Revenue Code Section 47; Ministerial Regulations No. 126, 390.
+*/
+const ThLevyContributionLabel = {
+	/** RMF contribution. */
+	Rmf: "allowance.retirement.rmf",
+	/** SSF contribution. */
+	Ssf: "allowance.retirement.ssf",
+	/** PVD contribution. */
+	Pvd: "allowance.retirement.pvd",
+	/** GPF contribution. */
+	Gpf: "allowance.retirement.gpf",
+	/** National Savings Fund contribution. */
+	Nsf: "allowance.retirement.nsf",
+	/** Pension life insurance premium. */
+	PensionLifeInsurance: "allowance.retirement.pension_life",
+	/** ThaiESG fund contribution. */
+	ThaiEsg: "allowance.thai_esg"
+};
+/**
+* Every income tally label the emitter reads, in Section 40 order.
+*
+* Purpose: Ordered contract a caller can iterate to label or audit income Flows.
+* Math: No arithmetic.
+* Units: Dimensionless label strings.
+* Throws: Nothing.
+* @statute Thailand Revenue Code Sections 40(1)–(8), 40(4).
+*/
+const TH_LEVY_INCOME_LABELS = [
+	ThLevyIncomeLabel.Section40_1,
+	ThLevyIncomeLabel.Section40_2,
+	ThLevyIncomeLabel.Section40_3,
+	ThLevyIncomeLabel.Section40_4Other,
+	ThLevyIncomeLabel.Section40_4Interest,
+	ThLevyIncomeLabel.Section40_4Dividends,
+	ThLevyIncomeLabel.Section40_4DigitalAssets,
+	ThLevyIncomeLabel.Section40_5Building,
+	ThLevyIncomeLabel.Section40_5AgriculturalLand,
+	ThLevyIncomeLabel.Section40_5NonAgriculturalLand,
+	ThLevyIncomeLabel.Section40_5Vehicles,
+	ThLevyIncomeLabel.Section40_5Other,
+	ThLevyIncomeLabel.Section40_6Medical,
+	ThLevyIncomeLabel.Section40_6Law,
+	ThLevyIncomeLabel.Section40_6Engineering,
+	ThLevyIncomeLabel.Section40_6Architecture,
+	ThLevyIncomeLabel.Section40_6Accounting,
+	ThLevyIncomeLabel.Section40_6FineArts,
+	ThLevyIncomeLabel.Section40_6Other,
+	ThLevyIncomeLabel.Section40_7,
+	ThLevyIncomeLabel.Section40_8General,
+	ThLevyIncomeLabel.Section40_8Entertainer
+];
+/**
+* Every contribution tally label the emitter reads, in retirement-cluster order.
+*
+* Purpose: Ordered contract a caller can iterate to label or audit contribution Flows.
+* Math: No arithmetic.
+* Units: Dimensionless label strings.
+* Throws: Nothing.
+* @statute Thailand Revenue Code Section 47; Ministerial Regulations No. 126, 390.
+*/
+const TH_LEVY_CONTRIBUTION_LABELS = [
+	ThLevyContributionLabel.Rmf,
+	ThLevyContributionLabel.Ssf,
+	ThLevyContributionLabel.Pvd,
+	ThLevyContributionLabel.Gpf,
+	ThLevyContributionLabel.Nsf,
+	ThLevyContributionLabel.PensionLifeInsurance,
+	ThLevyContributionLabel.ThaiEsg
+];
+// src/th/levy/allowances-retirement.ts
+/**
+* Emits the Retirement Cluster and ThaiESG allowances from `funded` tallies.
+*
+* Purpose: Mirrors the percentage and ceiling caps of both retirement allowances.
+* Math: RMF/SSF/PVD/GPF and pension life insurance are capped at `min(income * rate, ceiling)`
+* (PVD/GPF on Section 40(1) wage, the rest on assessable income); NSF at its flat ceiling; the
+* six are then capped at the 500,000 THB cluster ceiling. ThaiESG is capped at
+* `min(assessable * 30%, 300,000)`.
+* Units: Integer satang Measures.
+* Throws: TaxValidationError if a statutory ceiling is not valid satang.
+*
+* @param graph Measure graph being built.
+* @param tallies Income and contribution tally ids.
+* @param assessable Assessable income Measure used as the percentage base.
+* @statute Thailand Revenue Code Section 47; Ministerial Regulations No. 126, 390.
+*/
+function addRetirementAllowances(graph, tallies, assessable) {
+	const p = TH_2026_PARAMETERS.allowances.retirementCluster;
+	const income = tallies.income;
+	const funded = tallies.contributions;
+	const wage = income[ThLevyIncomeLabel.Section40_1];
+	const individual = sumMeasures(graph, [
+		graph.min(funded[ThLevyContributionLabel.Rmf], rateCapAt(graph, assessable, p.rmf.maxRate, toSatang(p.rmf.ceiling, "allowance.retirement.rmf"))),
+		graph.min(funded[ThLevyContributionLabel.Ssf], rateCapAt(graph, assessable, p.ssf.maxRate, toSatang(p.ssf.ceiling, "allowance.retirement.ssf"))),
+		graph.min(funded[ThLevyContributionLabel.Pvd], rateCapAt(graph, wage, p.pvd.maxRate, toSatang(p.pvd.ceiling, "allowance.retirement.pvd"))),
+		graph.min(funded[ThLevyContributionLabel.Gpf], rateCapAt(graph, wage, p.gpf.maxRate, toSatang(p.gpf.ceiling, "allowance.retirement.gpf"))),
+		graph.min(funded[ThLevyContributionLabel.Nsf], graph.constant(toSatang(p.nsf.ceiling, "allowance.retirement.nsf"))),
+		graph.min(funded[ThLevyContributionLabel.PensionLifeInsurance], rateCapAt(graph, assessable, p.pensionLifeInsurance.maxRate, toSatang(p.pensionLifeInsurance.ceiling, "allowance.retirement.pension_life")))
+	]);
+	const cluster = graph.min(individual, graph.constant(toSatang(p.combinedCeiling, "allowance.retirement_cluster")), "allowances.retirement_cluster");
+	const esg = TH_2026_PARAMETERS.allowances.thaiEsg;
+	return {
+		cluster,
+		thaiEsg: graph.min(funded[ThLevyContributionLabel.ThaiEsg], rateCapAt(graph, assessable, esg.maxRate, toSatang(esg.ceiling, "allowance.thai_esg")), "allowances.thai_esg")
+	};
+}
+// src/th/levy/allowances.ts
+/**
+* Emits every Section 47 allowance and derives net taxable income.
+*
+* Purpose: Orders the fixed, retirement, ThaiESG, and donation rules into one pipeline.
+* Math: `netBefore = max(0, assessable - expenses - fixed - cluster - ThaiESG)`, then donations
+* are capped against that net; `netTaxable = max(0, netBefore - allowed donations)`.
+* Units: Integer satang Measures.
+* Throws: TaxValidationError for an invalid profile allowance or donation amount.
+*
+* @param graph Measure graph being built.
+* @param tallies Income and contribution tally ids.
+* @param profile Emit-time filing status and allowances.
+* @param assessable Assessable income Measure used as the percentage base.
+* @param expenses Total expense deduction Measure.
+* @statute Thailand Revenue Code Section 47.
+*/
+function addAllowanceMeasures(graph, tallies, profile, assessable, expenses) {
+	const fixed = addFixedAllowances(graph, profile.allowances, profile.filingStatus ?? "single");
+	const retirement = addRetirementAllowances(graph, tallies, assessable);
+	const nonDonation = sumMeasures(graph, [
+		fixed,
+		retirement.cluster,
+		retirement.thaiEsg
+	]);
+	const donations = addDonationAllowances(graph, graph.max(graph.sub(graph.sub(assessable, expenses), nonDonation), graph.constant(0)), profile.allowances?.donation2x, profile.allowances?.donation1x);
+	return {
+		total: graph.add(nonDonation, donations.total, "allowances.total"),
+		netTaxable: donations.netTaxable
+	};
+}
+// src/th/levy/assessable.ts
+/**
+* Emits the Section 40 assessable income totals.
+*
+* Purpose: Sums every Section 40 class after the Section 40(4) election split.
+* Math: total = 40(1) + 40(2) + 40(3) + 40(4) assessable + 40(5) + 40(6) + 40(7) + 40(8);
+* gross non-employment = the same sum without Section 40(1).
+* Units: Integer satang Measures.
+* Throws: Nothing; every input is a caller-supplied tally Measure.
+*
+* @param graph Measure graph being built.
+* @param tallies Income tally ids.
+* @param section40_4 Resolved Section 40(4) assessable Measure.
+* @statute Thailand Revenue Code Sections 40(1)–(8), 48(2).
+*/
+function addAssessableMeasures(graph, tallies, section40_4) {
+	const income = tallies.income;
+	const rental = sumMeasures(graph, [
+		income[ThLevyIncomeLabel.Section40_5Building],
+		income[ThLevyIncomeLabel.Section40_5AgriculturalLand],
+		income[ThLevyIncomeLabel.Section40_5NonAgriculturalLand],
+		income[ThLevyIncomeLabel.Section40_5Vehicles],
+		income[ThLevyIncomeLabel.Section40_5Other]
+	]);
+	const professions = sumMeasures(graph, [
+		income[ThLevyIncomeLabel.Section40_6Medical],
+		income[ThLevyIncomeLabel.Section40_6Law],
+		income[ThLevyIncomeLabel.Section40_6Engineering],
+		income[ThLevyIncomeLabel.Section40_6Architecture],
+		income[ThLevyIncomeLabel.Section40_6Accounting],
+		income[ThLevyIncomeLabel.Section40_6FineArts],
+		income[ThLevyIncomeLabel.Section40_6Other]
+	]);
+	const business = sumMeasures(graph, [income[ThLevyIncomeLabel.Section40_8General], income[ThLevyIncomeLabel.Section40_8Entertainer]]);
+	const employment = income[ThLevyIncomeLabel.Section40_1];
+	const nonEmployment = [
+		income[ThLevyIncomeLabel.Section40_2],
+		income[ThLevyIncomeLabel.Section40_3],
+		section40_4.assessable,
+		rental,
+		professions,
+		income[ThLevyIncomeLabel.Section40_7],
+		business
+	];
+	return {
+		total: sumMeasures(graph, [employment, ...nonEmployment], "assessable.total"),
+		grossNonEmployment: sumMeasures(graph, nonEmployment, "assessable.non_employment")
+	};
+}
+// src/th/levy/brackets.ts
+/**
+* Emits progressive Section 48(1) tax as one slice per bracket tier.
+*
+* Purpose: Reproduces `evaluateBrackets` slice by slice as Measures.
+* Math: For tier `[lo, hi)` at rate `r`, tax += `round_half_up(min(max(x - lo, 0), hi - lo) * r)`;
+* the unbounded top tier omits the upper cap. Slices match `evaluateBrackets` exactly.
+* Units: Taxable income and tax are integer satang Measures; rates are dimensionless.
+* Throws: TaxValidationError if a bracket bound or rate is invalid.
+*
+* @param graph Measure graph being built.
+* @param taxable Net taxable income Measure.
+* @param brackets Ordered statutory bracket table in THB major units.
+* @statute Thailand Revenue Code Section 48(1); Royal Decree No. 650.
+*/
+function addProgressiveTax(graph, taxable, brackets = TH_2026_PARAMETERS.brackets) {
+	const taxes = [];
+	let lower = 0;
+	for (const bracket of brackets) {
+		const upper = bracket.upTo === null ? null : toSatang(bracket.upTo);
+		const excess = graph.max(graph.sub(taxable, graph.constant(lower)), graph.constant(0));
+		const slice = upper === null ? excess : graph.min(excess, graph.constant(upper - lower));
+		const { num, den } = rateFraction(bracket.rate);
+		taxes.push(graph.scale(slice, num, den, ThLevyRounding.HalfUp));
+		lower = upper ?? lower;
+	}
+	return sumMeasures(graph, taxes, "tax.progressive");
+}
+/**
+* Emits the Section 48(2) minimum gross tax and its applicability test.
+*
+* Purpose: Encodes both statutory thresholds as `pick` Measures.
+* Math: `calculated = gross >= 120,000 ? round_half_up(gross * 0.5%) : 0`;
+* `applicable = calculated > 5,000 ? calculated : 0`.
+* Units: Integer satang Measures; the threshold comparison uses satang.
+* Throws: TaxValidationError if the rate or a threshold is invalid.
+*
+* @param graph Measure graph being built.
+* @param grossNonEmployment Section 40(2)–(8) gross income Measure.
+* @statute Thailand Revenue Code Section 48(2).
+*/
+function addMinimumGrossTax(graph, grossNonEmployment) {
+	const p = TH_2026_PARAMETERS.minimumGrossTax;
+	const { num, den } = rateFraction(p.rate);
+	const computed = graph.scale(grossNonEmployment, num, den, ThLevyRounding.HalfUp);
+	const calculated = graph.pick(grossNonEmployment, graph.constant(toSatang(p.incomeThreshold) - 1), computed, graph.constant(0), "tax.minimum");
+	return {
+		calculated,
+		applicable: graph.pick(calculated, graph.constant(toSatang(p.taxThreshold)), calculated, graph.constant(0))
+	};
+}
+/**
+* Emits the regular-schedule tax: the larger of progressive tax and applicable minimum gross tax.
+*
+* Purpose: Encodes Section 48(2)'s "payable only if it exceeds" rule as `max`.
+* Math: `max(progressive, applicableMinimum)`.
+* Units: Integer satang Measures.
+* Throws: Nothing.
+*
+* @param graph Measure graph being built.
+* @param progressive Progressive bracket tax Measure.
+* @param applicableMinimum Minimum gross tax once the 5,000 THB floor applies.
+* @statute Thailand Revenue Code Sections 48(1)–(2).
+*/
+function addRegularTax(graph, progressive, applicableMinimum) {
+	return graph.max(progressive, applicableMinimum, "tax.regular");
+}
+// src/th/levy/expense-item.ts
+/**
+* Emits the actual-expense branch: `min(actual, income)`, matching `clampCap(actual, income)`.
+*
+* Purpose: Shared actual-expense Measure for every electable Section 40 item.
+* Math: `min(tally, actualExpense)` in satang.
+* Units: Actual expense is THB major units in, satang Measures out.
+* Throws: TaxValidationError if the actual expense is negative, NaN, or non-finite.
+*
+* @param graph Measure graph being built.
+* @param tally Tally Measure of the item's income.
+* @param choice Election carrying the actual expense.
+* @param field Diagnostic field name.
+* @statute Thailand Revenue Code Sections 42 ter, 43–46; Royal Decree No. 11.
+*/
+function addActualExpense(graph, tally, choice, field) {
+	const actual = choice?.actualExpense ?? 0;
+	validateMonetaryAmount(actual, field);
+	return graph.min(tally, graph.constant(toSatang(actual, field)));
+}
+/**
+* Emits one Section 40 expense deduction, either actual-capped-at-income or the standard percentage.
+*
+* Purpose: Selects the election branch and applies the item's statutory formula.
+* Math: Actual election gives `min(actual, income)`; otherwise `min(floor(income * rate), cap)`
+* expressed in whole baht, reproducing the calculator's `Math.floor(major * rate)` step.
+* Units: Measures are integer satang; `rate` is dimensionless.
+* Throws: TaxValidationError if the actual expense is invalid.
+*
+* @param graph Measure graph being built.
+* @param line Expense line specification.
+* @statute Thailand Revenue Code Sections 42 bis, 42 ter, 43–46; Royal Decree No. 11.
+*/
+function addItemExpense(graph, line) {
+	if (line.choice?.election === "actual") return addActualExpense(graph, line.tally, line.choice, line.field);
+	const standard = rateFlooredToBaht(graph, line.tally, line.rate);
+	return line.capSatang === void 0 ? standard : capAt(graph, standard, line.capSatang);
+}
+/**
+* Emits and sums a list of expense lines, one per Section 40 item or sub-category.
+*
+* Purpose: Keeps multi-class categories such as rentals and professions readable.
+* Math: `sum(addItemExpense(line))`; an empty list is zero.
+* Units: Integer satang Measures.
+* Throws: TaxValidationError if an elected actual expense is invalid.
+*
+* @param graph Measure graph being built.
+* @param lines Expense lines for one Section 40 category.
+* @statute Thailand Revenue Code Sections 42 bis, 42 ter, 43–46; Royal Decree No. 11.
+*/
+function addExpenseLines(graph, lines) {
+	return sumMeasures(graph, lines.map((line) => addItemExpense(graph, line)));
+}
+// src/th/levy/expenses-business.ts
+function addEntertainerExpense(graph, tally, choice) {
+	const entertainer = choice?.entertainer;
+	const field = "expense.40_8.entertainer";
+	if (entertainer?.election === "actual") return addActualExpense(graph, tally, entertainer, field);
+	const p = TH_2026_PARAMETERS.expenses.section40_8;
+	const threshold = toSatang(p.entertainerFirstTierThreshold, field);
+	const firstTier = graph.min(tally, graph.constant(threshold));
+	const secondTier = graph.max(graph.sub(tally, graph.constant(threshold)), graph.constant(0));
+	return capAt(graph, graph.add(rateFlooredToBaht(graph, firstTier, p.entertainerFirstTierRate), rateFlooredToBaht(graph, secondTier, p.entertainerSecondTierRate)), toSatang(p.entertainerCeiling, field));
+}
+/**
+* Emits the Section 40(8) business expense: general income at 60%, entertainer income on the
+* 60%/40% two-tier schedule capped at 600,000 THB; actual expenses cap at their income.
+*
+* Purpose: Mirrors both Section 40(8) expense schedules and their actual-expense elections.
+* Math: General `floor(income * 0.6)`. Entertainer
+* `min(floor(min(income, 300000) * 0.6) + floor(max(income - 300000, 0) * 0.4), 600000)`.
+* Units: Integer satang Measures.
+* Throws: TaxValidationError if an elected actual expense is invalid.
+* @statute Thailand Royal Decree No. 11 Section 8.
+*/
+function addSection40_8Expense(graph, tallies, choice) {
+	const rates = TH_2026_PARAMETERS.expenses.section40_8;
+	const income = tallies.income;
+	return sumMeasures(graph, [addItemExpense(graph, {
+		tally: income[ThLevyIncomeLabel.Section40_8General],
+		choice: choice?.general,
+		rate: rates.generalRate,
+		field: "expense.40_8.general"
+	}), addEntertainerExpense(graph, income[ThLevyIncomeLabel.Section40_8Entertainer], choice)]);
+}
+// src/th/levy/expenses-contracting.ts
+/**
+* Emits the Section 40(7) contracting expense: standard 60%, or actual capped at the income.
+*
+* Purpose: Mirrors the contracting expense deduction and its actual-expense election.
+* Math: `floor(s7 * 0.6)` or `min(actual, s7)`.
+* Units: Integer satang Measures.
+* Throws: TaxValidationError if the elected actual expense is invalid.
+* @statute Thailand Royal Decree No. 11 Section 7.
+*/
+function addSection40_7Expense(graph, tallies, choice) {
+	return addItemExpense(graph, {
+		tally: tallies.income[ThLevyIncomeLabel.Section40_7],
+		choice,
+		rate: TH_2026_PARAMETERS.expenses.section40_7.rate,
+		field: "expense.40_7"
+	});
+}
+// src/th/levy/expenses-income.ts
+/**
+* Emits the shared Section 40(1) and 40(2) expense: 50% of their combined income, capped at
+* 100,000 THB.
+*
+* Purpose: Mirrors the shared employment/service expense deduction as Measures.
+* Math: `min(floor((s1 + s2) * 0.5), 100000)` in whole baht, summed before the percentage.
+* Units: Integer satang Measures.
+* Throws: Nothing; both tallies are caller-supplied integer satang.
+* @statute Thailand Revenue Code Section 42 bis.
+*/
+function addSection40_1_2Expense(graph, tallies) {
+	const income = tallies.income;
+	const combined = graph.add(income[ThLevyIncomeLabel.Section40_1], income[ThLevyIncomeLabel.Section40_2]);
+	const rate = TH_2026_PARAMETERS.expenses.section40_1_2;
+	return addItemExpense(graph, {
+		tally: combined,
+		rate: rate.rate,
+		field: "expense.40_1_2",
+		capSatang: toSatang(rate.ceiling, "expense.40_1_2")
+	});
+}
+/**
+* Emits the Section 40(3) royalty expense: standard 50% capped at 100,000 THB, or actual capped
+* at the royalty income.
+*
+* Purpose: Mirrors the royalty expense deduction, including its actual-expense election.
+* Math: `min(floor(s3 * 0.5), 100000)` or `min(actual, s3)`.
+* Units: Integer satang Measures.
+* Throws: TaxValidationError if the elected actual expense is invalid.
+* @statute Thailand Revenue Code Section 42 ter; Royal Decree No. 11 Section 4.
+*/
+function addSection40_3Expense(graph, tallies, choice) {
+	const rate = TH_2026_PARAMETERS.expenses.section40_3;
+	return addItemExpense(graph, {
+		tally: tallies.income[ThLevyIncomeLabel.Section40_3],
+		choice,
+		rate: rate.rate,
+		field: "expense.40_3",
+		capSatang: toSatang(rate.ceiling, "expense.40_3")
+	});
+}
+/**
+* Emits the Section 40(4) expense, statutorily zero.
+*
+* Purpose: Keeps the expense total's shape identical to the calculator's.
+* Math: `0`.
+* Units: Integer satang.
+* Throws: Nothing.
+* @statute Thailand Revenue Code Section 40(4).
+*/
+function addSection40_4Expense(graph) {
+	return graph.constant(0);
+}
+// src/th/levy/expenses-professions.ts
+/**
+* Emits the Section 40(6) liberal profession expense: 60% for medical, 30% for every other
+* profession; actual expenses cap at their class income.
+*
+* Purpose: Mirrors each profession class's standard percentage or actual-expense election.
+* Math: Per class, `floor(income * rate)` with medical 60% and the rest 30%.
+* Units: Integer satang Measures.
+* Throws: TaxValidationError if an elected actual expense is invalid.
+* @statute Thailand Royal Decree No. 11 Section 6.
+*/
+function addSection40_6Expense(graph, tallies, choice) {
+	const income = tallies.income;
+	const rates = TH_2026_PARAMETERS.expenses.section40_6;
+	return addExpenseLines(graph, [
+		{
+			tally: income[ThLevyIncomeLabel.Section40_6Medical],
+			choice: choice?.medical,
+			rate: rates.medical,
+			field: "expense.40_6.medical"
+		},
+		{
+			tally: income[ThLevyIncomeLabel.Section40_6Law],
+			choice: choice?.law,
+			rate: rates.other,
+			field: "expense.40_6.law"
+		},
+		{
+			tally: income[ThLevyIncomeLabel.Section40_6Engineering],
+			choice: choice?.engineering,
+			rate: rates.other,
+			field: "expense.40_6.eng"
+		},
+		{
+			tally: income[ThLevyIncomeLabel.Section40_6Architecture],
+			choice: choice?.architecture,
+			rate: rates.other,
+			field: "expense.40_6.arch"
+		},
+		{
+			tally: income[ThLevyIncomeLabel.Section40_6Accounting],
+			choice: choice?.accounting,
+			rate: rates.other,
+			field: "expense.40_6.acc"
+		},
+		{
+			tally: income[ThLevyIncomeLabel.Section40_6FineArts],
+			choice: choice?.fineArts,
+			rate: rates.other,
+			field: "expense.40_6.art"
+		},
+		{
+			tally: income[ThLevyIncomeLabel.Section40_6Other],
+			choice: choice?.other,
+			rate: rates.other,
+			field: "expense.40_6.other"
+		}
+	]);
+}
+// src/th/levy/expenses-rental.ts
+/**
+* Emits the Section 40(5) rental expense across the five property classes.
+*
+* Purpose: Mirrors each rental class's standard percentage or actual-expense election.
+* Math: Per class, `floor(income * rate)` with building 30%, agricultural land 20%,
+* non-agricultural land 15%, vehicles 30%, other 10%; actual expenses cap at their class income.
+* Units: Integer satang Measures.
+* Throws: TaxValidationError if an elected actual expense is invalid.
+* @statute Thailand Royal Decree No. 11 Section 5.
+*/
+function addSection40_5Expense(graph, tallies, choice) {
+	const income = tallies.income;
+	const rates = TH_2026_PARAMETERS.expenses.section40_5;
+	return addExpenseLines(graph, [
+		{
+			tally: income[ThLevyIncomeLabel.Section40_5Building],
+			choice: choice?.building,
+			rate: rates.building,
+			field: "expense.40_5.building"
+		},
+		{
+			tally: income[ThLevyIncomeLabel.Section40_5AgriculturalLand],
+			choice: choice?.agriculturalLand,
+			rate: rates.agriculturalLand,
+			field: "expense.40_5.agri"
+		},
+		{
+			tally: income[ThLevyIncomeLabel.Section40_5NonAgriculturalLand],
+			choice: choice?.nonAgriculturalLand,
+			rate: rates.nonAgriculturalLand,
+			field: "expense.40_5.nonAgri"
+		},
+		{
+			tally: income[ThLevyIncomeLabel.Section40_5Vehicles],
+			choice: choice?.vehicles,
+			rate: rates.vehicles,
+			field: "expense.40_5.vehicles"
+		},
+		{
+			tally: income[ThLevyIncomeLabel.Section40_5Other],
+			choice: choice?.other,
+			rate: rates.other,
+			field: "expense.40_5.other"
+		}
+	]);
+}
+// src/th/levy/expenses.ts
+/**
+* Emits every Section 40(1)–40(8) expense deduction and totals them.
+*
+* Purpose: Reproduces the calculator's `calculateExpenseDeductions` as Measures.
+* Math: Sum of the seven statutory expense buckets, each already rounded the way its stage does.
+* Units: Integer satang Measures.
+* Throws: TaxValidationError if an elected actual expense is invalid.
+*
+* @param graph Measure graph being built.
+* @param tallies Income tally ids.
+* @param elections Standard-versus-actual choices fixed at emit time.
+* @statute Thailand Revenue Code Sections 42 bis, 42 ter, 43–46; Royal Decree No. 11.
+*/
+function addExpenseMeasures(graph, tallies, elections = {}) {
+	return sumMeasures(graph, [
+		addSection40_1_2Expense(graph, tallies),
+		addSection40_3Expense(graph, tallies, elections.section40_3),
+		addSection40_4Expense(graph),
+		addSection40_5Expense(graph, tallies, elections.section40_5),
+		addSection40_6Expense(graph, tallies, elections.section40_6),
+		addSection40_7Expense(graph, tallies, elections.section40_7),
+		addSection40_8Expense(graph, tallies, elections.section40_8)
+	], "expenses.total");
+}
+// src/th/levy/graph.ts
+/** Auto-generated Measure id prefix; explicit audited ids never start with it. */
+const AUTO_ID = "auto";
+/**
+* Builder for a sim-core `Levy` rule graph.
+*
+* Purpose: The only place that constructs Measures, so the emitted operation set is closed by
+* the {@link ThLevyMeasure} union and every id is unique.
+* Math: Each method appends one Measure; arithmetic is deferred to sim-core's exact evaluator.
+* Units: `const` values are integer satang; `num`/`den` of `scale` are dimensionless integers.
+* Throws: TaxValidationError for a duplicate id, non-safe const, or invalid scale fraction.
+*
+* @statute Thailand Revenue Code Sections 40, 42 bis, 47, 47 bis, 48(1)–(2).
+*/
+var ThLevyGraph = class {
+	list = [];
+	ids = /* @__PURE__ */ new Set();
+	serial = 0;
+	/** Appends a fixed satang amount; `id` names an audited Measure. */
+	constant(value, id) {
+		if (!Number.isSafeInteger(value)) throw new TaxValidationError("levy.measure.const.value", value, "Const must be safe integer satang");
+		return this.append({
+			id: this.claim(id),
+			op: "const",
+			value
+		});
+	}
+	/** Appends a tally over one label and basis. */
+	tally(label, basis, id) {
+		return this.append({
+			id: this.claim(id),
+			op: "tally",
+			label,
+			basis
+		});
+	}
+	/** Appends `a + b`. */
+	add(a, b, id) {
+		return this.append({
+			id: this.claim(id),
+			op: "add",
+			a,
+			b
+		});
+	}
+	/** Appends `a - b`. */
+	sub(a, b, id) {
+		return this.append({
+			id: this.claim(id),
+			op: "sub",
+			a,
+			b
+		});
+	}
+	/** Appends `min(a, b)`. */
+	min(a, b, id) {
+		return this.append({
+			id: this.claim(id),
+			op: "min",
+			a,
+			b
+		});
+	}
+	/** Appends `max(a, b)`. */
+	max(a, b, id) {
+		return this.append({
+			id: this.claim(id),
+			op: "max",
+			a,
+			b
+		});
+	}
+	/** Appends `of * num / den`, rounded as `rounding` says. */
+	scale(of, num, den, rounding, id) {
+		if (!Number.isSafeInteger(num)) throw new TaxValidationError("levy.measure.scale.num", num, "Scale numerator must be an integer");
+		if (!Number.isSafeInteger(den) || den < 1) throw new TaxValidationError("levy.measure.scale.den", den, "Scale denominator must be >= 1");
+		return this.append({
+			id: this.claim(id),
+			op: "scale",
+			of,
+			num,
+			den,
+			rounding
+		});
+	}
+	/** Appends `then` when `a > b`, otherwise `otherwise`. */
+	pick(a, b, then, otherwise, id) {
+		return this.append({
+			id: this.claim(id),
+			op: "pick",
+			a,
+			b,
+			then,
+			else: otherwise
+		});
+	}
+	/** Finishes the graph as a Levy, checking that every operand and the due id exist. */
+	build(id, period, settlement, due) {
+		if (!this.ids.has(due)) throw new TaxValidationError("levy.measure.due", due, "Due must name an emitted Measure");
+		for (const measure of this.list) for (const operand of operandsOf(measure)) if (!this.ids.has(operand)) throw new TaxValidationError("levy.measure.id", operand, "Operand must name an emitted Measure");
+		return {
+			id,
+			period,
+			settlement,
+			measures: [...this.list],
+			due
+		};
+	}
+	append(measure) {
+		this.list.push(measure);
+		return measure.id;
+	}
+	claim(id) {
+		const resolved = id ?? `${AUTO_ID}.${this.serial++}`;
+		if (this.ids.has(resolved)) throw new TaxValidationError("levy.measure.id", resolved, "Duplicate Measure id");
+		this.ids.add(resolved);
+		return resolved;
+	}
+};
+function operandsOf(measure) {
+	switch (measure.op) {
+		case "const":
+		case "tally": return [];
+		case "scale": return [measure.of];
+		case "pick": return [
+			measure.a,
+			measure.b,
+			measure.then,
+			measure.else
+		];
+		default: return [measure.a, measure.b];
+	}
+}
+// src/th/levy/regimes.ts
+function withheld(graph, tally, rate) {
+	const { num, den } = rateFraction(rate);
+	return graph.scale(tally, num, den, ThLevyRounding.HalfUp);
+}
+/**
+* Emits the Section 40(4) split: sources elected final leave regular brackets and carry their
+* withholding tax; included sources join Section 40(4) income, and included dividends also earn
+* the Section 47 bis gross-up credit.
+*
+* Purpose: Applies each source's emit-time election and builds the Section 47 bis credit.
+* Math: Final tax = `round_half_up(amount * rate)`; credit = `round_half_up(dividend * r / (1-r))`;
+* assessable = sum of included sources + credit.
+* Units: Integer satang Measures; rates are dimensionless.
+* Throws: TaxValidationError if the corporate tax rate is outside [0, 1).
+*
+* @param graph Measure graph being built.
+* @param tallies Income tally ids.
+* @param elections Final-withholding and Section 47 bis elections fixed at emit time.
+* @statute Thailand Revenue Code Sections 40(4), 47 bis, 50(2)(g), 57 ter.
+*/
+function addSection40_4(graph, tallies, elections = {}) {
+	const rates = TH_2026_PARAMETERS.finalWithholding;
+	const income = tallies.income;
+	const corpTaxRate = elections.dividendCorpTaxRate;
+	if (corpTaxRate !== void 0) validateCorpTaxRate(corpTaxRate);
+	const isFinal = (election) => election === ThFinalWithholdingElection.Final;
+	const included = [income[ThLevyIncomeLabel.Section40_4Other]];
+	const finalTaxes = [];
+	const interest = income[ThLevyIncomeLabel.Section40_4Interest];
+	if (isFinal(elections.interest)) finalTaxes.push(withheld(graph, interest, rates.interestRate));
+	else included.push(interest);
+	const dividend = income[ThLevyIncomeLabel.Section40_4Dividends];
+	const isDividendIncluded = !isFinal(elections.dividends);
+	if (isDividendIncluded) included.push(dividend);
+	else finalTaxes.push(withheld(graph, dividend, rates.dividendRate));
+	const digital = income[ThLevyIncomeLabel.Section40_4DigitalAssets];
+	if (isFinal(elections.digitalAssets)) finalTaxes.push(withheld(graph, digital, rates.digitalAssetRate));
+	else included.push(digital);
+	let credit;
+	if (isDividendIncluded && corpTaxRate !== void 0) {
+		const { num, den } = rateFraction(corpTaxRate);
+		credit = graph.scale(dividend, num, den - num, ThLevyRounding.HalfUp, "credit.dividend");
+		included.push(credit);
+	} else credit = graph.constant(0, "credit.dividend");
+	return {
+		assessable: sumMeasures(graph, included),
+		finalWithholdingTax: sumMeasures(graph, finalTaxes, "tax.final_withholding"),
+		dividendCredit: credit
+	};
+}
+// src/th/levy/tallies.ts
+function tallyRecord(graph, labels, basis) {
+	const record = {};
+	for (const label of labels) record[label] = graph.tally(label, basis);
+	return record;
+}
+/**
+* Emits one tally Measure per exported label, so a caller can label any subset of Flows.
+*
+* Purpose: Fixes the caller-facing contract before any statutory arithmetic depends on it.
+* Math: No arithmetic; each Measure only reads its label from the matching sim-core tally map.
+* Units: Tallied amounts are integer satang supplied by the caller.
+* Throws: Nothing; the graph validates ids only.
+*
+* @param graph Measure graph being built.
+* @statute Thailand Revenue Code Sections 40(1)–(8), 47.
+*/
+function addThLevyTallies(graph) {
+	return {
+		income: tallyRecord(graph, TH_LEVY_INCOME_LABELS, ThLevyTallyBasis.Gross),
+		contributions: tallyRecord(graph, TH_LEVY_CONTRIBUTION_LABELS, ThLevyTallyBasis.Funded)
+	};
+}
+// src/th/levy/emit.ts
+/** Default Levy id: Thailand Personal Income Tax for the 2026 tax year. */
+const DEFAULT_ID = "th-2026-pit";
+/** Default period start: the calendar tax year. */
+const DEFAULT_PERIOD = {
+	month: 1,
+	day: 1
+};
+/** Default Settlement: the annual return date following the tax year (Revenue Code Section 56). */
+const DEFAULT_SETTLEMENT = {
+	month: 3,
+	day: 31
+};
+/**
+* Emits a Thailand 2026 Personal Income Tax rule set as sim-core Levy data.
+*
+* Purpose: Lets sim-core charge the annual PIT assessment from Flow tallies without importing
+* this package. The profile, elections, and 2026 statutory parameters are frozen at emit time;
+* income and contribution amounts arrive as Flow tallies under the exported labels.
+* Math: `due = max(progressive, minimum gross tax) + final withholding tax
+* - final withholding tax - Section 47 bis credit`, which is the calculator's `netTaxPayable`
+* when no separate sheet, real estate, or other withholding is supplied.
+* Units: Every monetary Measure is integer satang.
+* Throws: TaxValidationError for an invalid profile allowance, donation, actual expense, or rate.
+*
+* @param profile Taxpayer profile and elections fixed at emit time.
+* @statute Thailand Revenue Code Sections 40, 42 bis, 47, 47 bis, 48(1)–(2), 50(2)(g), 56.
+*/
+function emitThLevy(profile = {}) {
+	const graph = new ThLevyGraph();
+	const tallies = addThLevyTallies(graph);
+	const section40_4 = addSection40_4(graph, tallies, profile.section40_4);
+	const assessable = addAssessableMeasures(graph, tallies, section40_4);
+	const expenses = addExpenseMeasures(graph, tallies, profile.expenses);
+	const regular = addRegularTax(graph, addProgressiveTax(graph, addAllowanceMeasures(graph, tallies, profile, assessable.total, expenses).netTaxable), addMinimumGrossTax(graph, assessable.grossNonEmployment).applicable);
+	const total = graph.add(regular, section40_4.finalWithholdingTax, "tax.total");
+	const credits = graph.add(section40_4.finalWithholdingTax, section40_4.dividendCredit);
+	const netPayable = graph.sub(total, credits, "tax.net_payable");
+	return graph.build(profile.levy?.id ?? DEFAULT_ID, profile.levy?.period ?? DEFAULT_PERIOD, profile.levy?.settlement ?? DEFAULT_SETTLEMENT, netPayable);
+}
 // src/th/system.ts
 /**
 * Thailand Tax System implementation for 2026.
@@ -1468,6 +2528,6 @@ const th = {
 		return calculateThTax(input);
 	}
 };
-export { TH_2026_PARAMETERS, ThFinalWithholdingElection, ThRealEstateAcquisitionType, ThRealEstateExpenseBasis, ThSeparateSheetPaymentType, calculateThTax, th };
+export { TH_2026_PARAMETERS, TH_LEVY_CONTRIBUTION_LABELS, TH_LEVY_INCOME_LABELS, ThFinalWithholdingElection, ThLevyContributionLabel, ThLevyIncomeLabel, ThLevyMeasureId, ThLevyRounding, ThLevyTallyBasis, ThRealEstateAcquisitionType, ThRealEstateExpenseBasis, ThSeparateSheetPaymentType, calculateThTax, emitThLevy, th };
 
 //# sourceMappingURL=index.mjs.map